World: r3wp

Gregg, we already have dependencies covered without using 'include. 
Using the word 'include has the advantage of discouraging people 
from reinventing the wheel, making yet another dependencies system.

Fortunately people can redefine the word as they like in R3, and 
it won't disturb existing code because of its module/dependency system.

BrianH, in 2.7.7:

types-of :now

returns a lot of type blocks. Is that correct?

It returns nine blocks which correspond to the nine refinements the 
NOW function has. I guess it's somewhat intended behaviour ...

Refinement arguments are either of type NONE! or of type LOGIC!, 
so there is a reasoning.

R3 does it too, so I suppose that is correct.

Yes, it is. And it makes sense:

>> apply :now [true none none none none none none none none]
== 2010
>> apply :now [none true none none none none none none none none]
== 2
>> apply :now [none true none none none none none none none]
== 2
>> apply :now [none none true none none none none none none]
== 28
>> apply :now [none none none true none none none none none]
== 13:26:18
>> apply :now [none none none none true none none none none]
== 1:00
>> apply :now [none none none none none true none none none]
== 28-Feb-2010
>> apply :now [none none none none none none true none none]
== 7
>> apply :now [none none none none none none none true none]
== 59
>> apply :now [none none none none none none none none none]
== 28-Feb-2010/13:26:47+1:00

(overfluous example no. 2 above)

With TYPES-OF you can decide about the argument ordering for APPLY 
and where to put the refinement switches.

>> apply :now []
== 28-Feb-2010/6:58:05-6:00

Any arguments you leave off the end are passed the value none, at 
least in R3. That should be the case in R2 as well.

The blocks of types returned by TYPES-OF in R2 can be used mostly 
the same as the typesets returned in R3. The typeset! datatype was 
faked in R2 - see also the TO-TYPESET and TYPESET? functions. You 
can use them with FIND and the set functions, but otherwise be careful. 
Be sure to use the FOUND? function on the result of FIND to get the 
same result, which is TRUE? but not true. There are some built-in 
fake typesets too; look at the source of ANY-OBJECT? for an example 
of use.

Btw, that APPLY trick with the missing arguments is used in USE in 
R3 to initialize the words to none. The source:
use: make function! [[
    "Defines words local to a block."
    vars [block! word!] "Local word(s) to the block"
    body [block!] "Block to evaluate"
][
    apply make closure! reduce [to block! vars copy/deep body] []
]]

Regarding cutting off arguments, that was "just another" typo. The 
last should have been 8 NONEs ending in a TRUE for the /PRECISE refinement.

Ah, that makes more sense.

Extra arguments in the block are ignored too, though the block is 
still reduced unless you use APPLY/only.

Oh, I never realised that USE is just a mezzanine ... cool stuff!

>> apply :now array 20
== 28-Feb-2010/7:21:53-6:00

USE is a mezzanine in R3, a native in R2. They made the behavior 
of R2's USE into a function datatype: closure!. And then Ladislav 
and I backported closure! to R2 as a fake datatype (though USE doesn't 
use it).

Hm, I'm wondering if it would be useful if the position of the block 
provided could be changed to after the last argument consumed? That 
would allow applying one block to more than one function.

The reference to the block provided is passed by value, not by name. 
You can't change the position of it, since position is a attribute 
of the block reference, not the block itself.

since position is a attribute of the block reference, not the block 
itself
 - that wasn't something I knew already ...

However, that doesn't mean you can't advance the position yourself. 
Use LENGTH? WORDS-OF function to get the amount to advance, and be 
sure to reduce the block yourself and use APPLY/only so that the 
result is what you want.

Yeah, the position being an attribute of the reference is one of 
the core parts of series behavior in REBOL. In contrast, in R3 ports 
the position is an attribute of the port, not the reference to the 
port; same with OPEN/direct ports in R2.

This means that SKIP is a pure function for series, returning a reference 
to a new position - while it is modifying when applied to ports, 
changing the internal position. Same with the other position functions 
like AT, HEAD and TAIL.

I know such things when writing code, but more in a subconcious way. 
Of course different references to the same block having different 
positions doesn't go together with position being an attribute of 
the block (series) itself. That's of course obvious after only a 
little amount of thinking ;-)

Wow ! I didn't noticed USE was not native anymore in R3...

Also, USE is broken in R3 in as it captures RETURN and EXIT. See 
bug#539.

Because USE make and do a closure! in R3 (which is a function).
Don't like that :-)

Look that alternate implementation of USE:

>> use2: funco [vars body][foreach :vars vars body]
>> use2 [a b][a: 1 b: 2  b + a]
== 3


The funny trick is that although the [a b] vars are locals to the 
block, we can pass values from the encompassing context.

>> a: 5
== 5

>> use2 [a][a: 1 + get a]
== 6

>> a
== 5

USE is not broken because it uses closure!, it's broken because R3 
functions don't support something like the [throw] attribute yet.

Note the "yet" - that's intended to be fixed.

ZERO?, TRUE? and coercion. I can't really deside what to think about 
these examples:

>> zero? 0.0.0
== true
>> 0.0.0 = 0
== false

>> true? 1
== true
>> 1 = true
== false

What do you guys think?

As ZERO is defined in REBOL, the first example could be:

>> zero? 0.0.0
== true
>> 0.0.0 = zero
== false

I agree with REBOL on 'zero? vs. = 0.

The TRUE? function was added specifically to give that answer, what 
is considered truth by the conditional functions. ZERO? compares 
to the zero value of the datatype.

If TRUE? compared directly to #[true] then there would be no point 
to the function.

Yes, there would in situations, where someone wants to set a variable 
to the truth value of something.

my-var: true? some-value

Someone might argue, that if conditional functions can operate on 
almost any value, then those values would be either true or false. 
Does it makes sense, that such values are neither true or false?

That is why TRUE? is there, to convert the truth value of something 
to a logic value.

>> "hey" = true
== false
>> "hey" = false
== false
>> if "hey" [print {"hey" is true}]
hey
 is true

It does make sense to have conditionals work on more than just logic 
values. Whether or not to do so is arbitrary, and many languages 
do so (mostly the Lisp-derived languages). It's one of the two main 
models.

The Pascal-derived languages only use logic (or boolean) values. 
The assembly-derived ones use 0 and non-0. Others are weirder.

The Icon-derived ones use success and failure - those are weird, 
but useful.

Can rebol save program state as an image?

no.

R2 challenge:


Implement a debug-function that uses a call-stack. I made this context:

context [
	action-level: 0
	func-name: make block! []

 set 'hint func [str] [reform [action-level: action-level + 1 ":" 
 str]]

 set 'doing func [name] [print hint join "Doing " last append func-name 
 name]

 set 'done does [print join "Done with " first name: back tail func-name 
 remove name action-level: action-level - 1]
	set 'last-hint does [print mold func-name]
]

And I use it like this:

my-func: func [] [
	doing 'my-func
	...stuff...
	done
]


What would it take to build a function that does this automatically, 
like:

my-func: debug-func [] [
	... stuff ...
]


and also automatically catches all exits, returns and throws and 
allows the function to return a value?

As this is built into R3, this is only for R2.

debug-func: function [name spec body] [b] [b: copy body insert b 
compose [doing (name)] append b [done] tfunc spec b]

ah, that was premature :)

reminder to self: should not draft code in the altme message area 
:)