World: r3wp

ahh, good point!

make-f-returning: func [x] [does [x]]
f-returning-ok: make-f-returning "ok"
f-returning-ok ; == "ok"
f-returning-wrong: make-f-returning "wrong"
f-returning-wrong ; == "wrong"
f-returning-ok ; == "wrong"

make-g-returning: closure [x] [does [x]]
g-returning-ok: make-g-returning "ok"
g-returning-ok ; == "ok"
g-returning-wrong: make-g-returning "wrong"
g-returning-wrong ; == "wrong"
g-returning-ok ; == "ok"

what do you say to this?

the alternative to the initialization block is to not use it and 
initialize everything to NONE like in the FUNC case

ok, I see the difference. And I guess, it's benefitial, because using 
bind can be difficult.

And your question is, if closure should have a third block with "cheap" 
initializations?

Like in your:
 c: closure [/local a] [a: 0] [a: a + 1]

the question is, if users want to have the additional (actually second) 
block for the initialization purposes of do not mind to have everything 
initialized to NONE

Damn hard question! :-)

It mayl be easier to say, when I've done 10 programs using closure. 
But I'll think about it.

may

you do not have to know anything about closure, you may imagine the 
same question for FUNC case: would you appreciate to be able to specify 
the initial values for locals?

Before I answer that..

I use FUNC all the time. I almost never use FUNCTION. I guess, because 
I have to write more with FUNCTION.
I also started to use HAS and DOES, when I found those.

CLOSURE may come in the group with FUNCTION, if it get 3 blocks as 
arguments, so I may not use it.

Could it be possible to make the initial assignments in the first 
(and only) argument block?

the only disadvantage of initialization I came to is the more complicated 
interface to CLOSURE needing always one more block to specify

I think, that's a very good point! REBOL programmers don't like to 
write much.

it may be possible to put the initializations into the first block 
but that would cost some syntax complications and differencess too...

yeah

Could we have 2 versions of closure, like we have func and function? 
One where init = NONE and one with the extra block?

probably yes, although Carl always hesitates to include unwanted 
features

I can understand that.

Let's see another example with the extra block:
f: closure [x /local a]Ê[a: 2 * pi] [(sine/radians x) / a]

without:
f: closure [x /local a] [a: 2 * pi (sine/radians x) / a]


Is it something like this, you're thinking about? And will the first 
be faster than the second?

And the third possibility (which maybe not is very REBOLish):
f: closure [x /local a: 2 * pi] [(sine/radians x) / a]

Ladislav, will rebcode be part of REBOL3? Do you know?

I do not know, but think so

Is the idea, that the second closure block will only be parsed one 
time? (and therefore be fast)

yes

Rebcode is mentioned on the roadmap doc

Ok, functions with many constants will be much faster with this extra 
block then, right?

faster, yes, much faster - maybe not

Where is your opinion against? With or without the extra block?

my opinion is not strong, therefore I am asking

hehe :)

the main point against it is the more complicated syntax, which could 
be used for static initialization, that may be even more useful sometimes

I have a feeling, that it'll be a little too much to write (like 
with function), and therefore I'll probably wont use it much.

too much to write: actually not, let's compare:

If the idea with closure is, that programmers having trouble with 
func (and feel going into using bind is difficult), then the more 
complicated syntax will also not be good, as you say.

f: closure [/local e] [e: exp 1 print e]
g: closure [/local e] [e: exp 1] [print e]

hm it doesn't look right to me. I think, because I'm not used to 
function (which also has 3 blocks). I would read it, as the second 
block is the function, and then I'll be confused, when seeing yet 
another block.

Wasn't closure called indefinite extend in rebol 1.0?

extent

You need to ask someone familar with function (and not just func).

>> length? "function [] [a] []"
== 18
>> length? "func [/local a] []"
== 18

Ladislav - I will read it tomorrow, as now I go to sleep - travelling 
to Prague tomorrow, so I better get some sleep ... but I do remember 
there were other goodies, which even I understood. Not sure now, 
if it was 'default ... I need to go via your materials once again 
...

default: no need to guess there, it will be called differently but 
*implemented* in Rebol3

Yes, the same amount to type. So it's not precisely true, that it's 
the amount, but also the more complicated syntax = more difficult 
to read.

ha, cool ... thanks :-) So in overall - what about some of your other 
enhancements? Any changes to parse? binding? object cloning? map? 
You know - your rebol pages contain lots of stuff - http://www.fm.vslib.cz/~ladislav/rebol/

Ladislav - what it was about with | or some other kind of assignment? 
IIRC it was rejected - just curious ...

What is the speed of this compared to using closure (with the extra 
block):
o: context [a: 2 * pi f: closure [x] [(sine/radians x) / a]]
And then call it by: o/f 1