World: r3wp

R2 example (you surprised me not knowing it):

>> f: func [x [any-type!]] [value? 'x]
>> f
== false

ah, but here you actually supplied unset to the function.

in a way, its not the same as not specifying the /refinement.

but yes, the line is thin.

>> g: func [/local x [any-type!]] [value? 'x]
>> g
== true
>> g/local
== false

(R2 example too)

but the use of  any-type! is what specifically allows this "trick".

R3 removed the ability to not supply arguments...

>> a: func [x [any-type!]][value? 'x]
>> a
** Script error: a is missing its x argument

IIRC this was the great "equalizer" when make was overhauled... it 
now always accepts exactly one argument, because it is forced to.

R2's behavior has always worked well for me. Unset is the special 
case I avoid unless I really, REALLY think there's a need to leverage 
it. I very rarely use any-type! for that reason. I like declared 
locals being NONE. I can't think of a time I tripped over using a 
refinement without passing its arg, but there unset would have to 
be intentionally expected as well.

>> b: func ['x [any-type!]][value? 'x]
>> b
== false

(R3)

Well, anyway, because of this, RebolTutorial completely ignoring 
any explanation makes a bad publicity to Rebol stating that "FUNCT 
and FUNC are incompatible", which is just nonsense.

ok, but that is a fringe case which probably got put there specifically 
to allow that specific pattern so that some command-line functions 
can be simplied... 
its not the intended use of Rebol.


argument passing by reference is rarely used (a few mezzanines and 
highly specialized situations)

Agreed. And things like the R3 behavior for a missing arg when using 
a lit-word! param versus a word! param would be good to note in the 
FUNC docs.

in the above cases, they should be unset, because in fact they are 
passed unset!

the 'x refers to no value

I think Ladislav dislikes lit-word params anyway, as they are a pain 
when generating code, but they make for good examples and thought 
experiments.

they are mainly used for command-lines and code analysis funcs (?? 
for example)

Explanation: the "partially evaluated arguments" as used in R3 are 
OK with me, I disliked their R2 counterparts.

OK. :-)

yes, I agree completely.  this is now an intended setup, not an interpreter 
loophole leveraged as a feature.

Lad, can you explain simply, what is the difference between func 
and funct which RebolTutorial claims?

I cannot, because there is none

ok

Example:

>> f: funct [] [[x:] value? 'x]
>> f
== true

but I meant what does HE claim is the difference?

RebolTutorial claims, that the behaviour of the above F differes 
from FUNC, which is just nonsense, since the SOURCE function tells 
us:

>> source f
f: make function! [[
    /local x
][[x:] value? 'x]]

I do not think it deserves any more comments

yeah, he doesn't seem to grasp that there is just one function! type 
 ;-)

and there is that nice little line in funct :   collect-words/deep/set/ignore

which pretty much explains it all  :-)

Nevertheless, the whole issue is related to his misunderstanding 
how the values of "unused refinement arguments" are set in functions

And, in my opinion, this actually *is* a gotcha for beginners

Since HELP tells us what the VALUE? function is supposed to do, which 
just does not look like being the case above

Reading the HELP string of the VALUE? function, I do not know, how 
I can reasonably expect F to yield #[true]

(which does not mean I don't respect Max's feelings on this)

The funny thing is, that the COLLECT-WORDS/IGNORE looks like being 
Tutorial's strategy when communicating with me ;-)

/local x  sets the value of x to none in the F above.
if F was defined like so instead (R2)

>> f: make function! [/local x [any-type!]][[x:] value? 'x]


then you can call it with with unspecified /local arguments and it 
will yield #[false]

>> f/local
== false

things is funct doesn't add that [any-type!] in its param block.

(for locals)

so yes... the value?  help string makes sense... its defined as a 
local within the function, as 'FUNCT is supposed to do automatically.

defined as a local

 - yes, that is true, but in my example below, 'x is clearly defined 
 as "nonlocal", yet the function yields #[false], in accordance with 
 its help string:

>> g: func [] [[x:] value? 'x]
>> g
== false

A little note about FUNCT vs. FUNCTOR: The word "functor" has a specific 
meaning in computer science, and that meaning is *not* what FUNCT 
does. There is no standard CS term for what FUNCT does, nor is there 
a standard English term. Any word we use would therefore have to 
be made up. FUNCT is not a bad made-up word: it's short, which is 
good for a function that will be used often in user code, and it 
starts with the same letters as FUNC and FUNCTION without being either 
one of those words.

I'd rather we use PROC then.

I strongly agree with Brian regarding the unsuitability of FUNCTOR.

Yes, I do agree too

actually Lad, if a word is defined but stores a value of unset!  
(like what happens above with the [x:]  value? returns false.

Some counterexamples where we messed this up:

- "functions" have side effects so they aren't really functions, 
they are procedures with return values.

- "closures" aren't really closures, though they are closer to that 
than REBOL "functions" are.
- "contexts" aren't contextual
The list goes on.

cause x actually has not ever been set.

so if I get you right,  in REBOL: 

contexts are actually closures, 
functs are actually functions 
and funcs are actually procedures

;-)

We actually had a function called FUNCTOR for a while, and it really 
created functors. And it went unused for more than a year, so we 
dropped it. It turned out that what FUNCT does is really useful, 
even though the concept is unique to REBOL. Apparently functors aren't.