World: r3wp

But you don't pass the function spec, you pass the function value. 
The function spec is the block with the parameters, types and doc 
strings. The function value is the value that gets assigned to the 
word that is used as the name of the function, it any.

it -> if

The function value is like :add, the function spec is (in R2) third 
:add or (in R3) spec-of :add.
>> print mold third :add
[
    "Returns the result of adding two values."
    value1 [number! pair! char! money! date! time! tuple!]
    value2 [number! pair! char! money! date! time! tuple!]
]

Brian .. some most certanly a crazy question ... is there a way you 
could walk/execute a block of code in steps ... this is probably 
possible (if they take no arguments)  [ func-1 func-2 func-3 ] ... 
but is there some "magic" way to execute make func consume their 
arguments, like this >> b: [ print "hello" add 4 6 ]<< and >>do get-expr 
b 1<< would print "hello" and >>do get-expr b 2<< would calcualate 
10 ... I know this is probably not even remotely possible

Yes, DO/next. But it doesn't work in R3 yet, just R2. That is a bug, 
btw.

what is a bug?

DO/next not working in R3. It's not an intentional change.

hm.. :) there really is do/next :)) awesome

aha... I was scared do/next is a bug :)

DO was rewritten in R3, and not all of the old behavior is implemented 
yet. Though there are some intentional differences.

LOAD was rewritten too, as a mezzanine, by me. There is still some 
missing functionality, and some fixes to bugs in R2's LOAD.

I am trying the do/next .. I can execute first expression but then 
I am a little lost of what to *do next* ( hehe)... >> b: copy [ empty? 
"" empty? "a" ]     do/next b == [true [empty " "]] <<  I tried >> 
b: next do/next b <<

set/any [value code] do/next code

'value gets set to the result of the first evaluation, 'code gets 
set to the code block at the position after the first expression.

aha, that's why it says it returns two things in help

so code is a code block and value is something that has a result 
that code block would return if I do it at the end ?

>> do/next [1 + 1 2 + 2]
== [2 [2 + 2]]

That last block is an offset reference to the original code block.

it works here too.. one strange thing is that at the last do/next 
I get right value for the end of the block and if I do/next again 
that value get's unset (I didn't know that is even possible) >>>value
** Script Error: value has no value
** Near: value<<<

>> mold/all do/next [1 + 1 2 + 2]
== "[2 #[block![1 + 1 2 + 2]4]]"

so now I just need to figure out how to detect when the last block 
is evaluated .. that is probably when the oftest block is empty...

Yup.

I mean the whole block .. (in a loop)

I will try

ha, works on all test blocks I tried :)   step-block: func [ code 
] [ until [ set/any [ value code ] do/next code empty? code ] value 
]

:)

I thought I will ask a very very stupid question and it turns out 
this is very nicely possible already

Except in R3, for now :(

would this enable us to do some sort of "green threading" without 
the need to maually yield even?

absolutely no problem , if it's "for now"

Yes, but watch out: If there is a function call, the *whole* call 
gets executed, even if it is long. Your granularity of preemption 
of your manual multithreading is going to be pretty coarse.

yes, I know.. no long running tasks as with coroutines for example 
( I am not really specialist in this, I only used it few times)

basically I don't have the full picture, it's just awesome that something 
like this can be done inside a language itself

It will be like cooperative multi-threading with no yield statement 
(that I can see), but an implied yield between top-level expressions.

yes, it looks like that .. I will try to make a simple step-blocks 
function and see what it does

if you would want to switch you could also step until you hit a certain 
word probably and then switch to other funct

With DO/next and pseudothreads you could do full fake cooperative 
multithreading.

what are pseudothreads?

you mean the R3 threads/processes?

Sorry, meant Protothreads: fake threading done with macros and special 
tricks. A C version: http://www.sics.se/~adam/pt/

The principle could be done in REBOL by preprocessing the code - 
easier than in C, though we don't have the switch trick.

C-style protothreads requires compilation to rebcode though, so we 
can use the brab opcode.

(the page doesn't load to me so I will keep trying)

Sorry, broken link. Try this: http://en.wikipedia.org/wiki/Protothreads

these things are very interesting to me but I am a little

uh.. I wanted to delete that but clicked the send button :) ..

Aren't we all "a little", sometimes :)

:)

is this how stackless works (because it mentions no stack)

If by "how stackless works" you mean Stackless Python, then no. That 
works using continuation passing style.

aha, I meant stackless pythong.. you seem to really understand this 
stuff :)