How value? function really works ?

Question

Isn't it weird that

ask-params: funct[config-file [file!] default-class-name default-fields][
  probe  value? 'class-name
  input
  either (value? 'class-name) [
    probe class-name
  ][
  ]
]

ret-block: ask-params %askcodegeneration.com/csharp/simple-class/simple-class.params.txt "Person" "First Name, Last Name"

would return false for value? 'class-name

but that

ask-params: funct[config-file [file!] default-class-name default-fields][
  probe  value? 'class-name
  input
  either (value? 'class-name) [
    probe class-name
  ][
    class-name: default-class-name
  ]
]

ret-block: ask-params %askcodegeneration.com/csharp/simple-class/simple-class.params.txt "Person" "First Name, Last Name"

would return true for value? 'class-name

In second case class-name: default-class-name isn't even executed yet so class-name shouldn't exist in memory and so value? 'class-name should not return true.

Answer 1

You are using 'funct. This scans the body of the function and creates the local variables for you so that value? 'class-name becomes true.

If you used 'func instead, then both would return false.

Answer 2

Here I show you two examples not using FUNCT, but otherwise equivalent to your code:

ask-params: func [config-file [file!] default-class-name default-fields] [
  probe  value? 'class-name
  input
  either (value? 'class-name) [
    probe class-name
  ][
  ]
]

ask-params: func [
  config-file [file!] default-class-name default-fields /local class-name
] [
  probe  value? 'class-name
  input
  either (value? 'class-name) [
    probe class-name
  ][
  ]
]

While the value? function in the first example yields #[true], in the second example it yields #[false]. That is because the "refinement arguments" following an "unused refinement" (a refinement that is not used in the actual call) are initialized to #[none!] together with the refinement variable. This applies to the /local variables as well, since the /local refinement does not differ from other function refinements (except for the fact, that it is a convention to use it to define local variables).

Since the funct function uses the /local method to implement local variables "under the hood", the above description applies to all functions it generates as well.

Answer 3

Correction to the note contained in the previous answer - actually the expected results of the value? function call should be the other way around, which means, that the function call in the first example is expected to yield #[false], while the function call in the second example is expected to yield #[true].

Since it looks, that there is a demand to not use FUNC/LOCAL call in the answer, here is another variant using FUNCT to compare:

ask-params: funct[config-file [file!] default-class-name default-fields][
  probe  value? 'class-name
  input
  either (value? 'class-name) [
    probe class-name
  ][
    set 'class-name default-class-name
  ]
]

Answer 4

I don't think funct behaves differently than func /local. Look at these examples:

>> f: func [/x] [value? 'x]
>> f
== true

I didn't give any value to x, but it says it HAS a value. Same for /local

>> f: func [/local x] [value? 'x]
>> f
== true

Because when you make a variable local (or a refinement) then it means you already set a value for it (which is none) and that is what funct does.