World: r3wp

However, this is still slower than APPLY closure in my tests.

Wait, you can't implement SELFLESS with native LET. The empty context 
would still not work.

Added the SELFLESS using LET code to the SELFLESS ticket.

Giving the 'self issue in objects another thought. It occurs to me, 
that we could be better off not having it at all, i.e. having all 
contexts seflless. An object method can refer to the object without 
using 'self anyway. E.g.:

o: make object! [this: does [bind? 'this]]
same? o o/this
== true

Or:

>> o: make object! [this: bind? 'this]
== make object! [
    this: make object! [...]
]

This would simplify the whole SELFLESS, SELFLESS?, LET, etc. issue 
as well

Aha, full circle. I seem to remember SELF was added by user request, 
and now it might be removed to simplify things. If I could remember 
why the user(s) wanted it...

When was it added?

In my opinion, it must have been before the BIND? function were available

Oh, long before that.

Maybe around 2001, on the mailing list.

IIRC there was a long discussion about SELFLESS functionality, it 
was imo backed mainly by BrianH, whereas some other members did not 
regard it being much important.

How about the LET function, Pekr, would you find such a function 
useful?

I haven't read those proposals yet ... might do so this evening - 
I am simply behind ...

LET would be useful to me.

I'm unclear on LETs value. Can someone provide a useful example?

Writing some, just a moment

Thanks

http://www.rebol.net/wiki/Exception_proposals#LET_2

Now it only depends whether you find those examples "useful". You 
can find other examples in the article, though.

(and they *are* useful)

Well, I think it would be clearer to see it applied in loops and 
using multiple values. As it is shown there, USE and DO FUNC are 
clearer to me. It may be very useful.

You find this example:


    x: 121 print ["result:" use 'x [x: system/contexts/user/x x: x + 
    1 x / 2 + x]]


clear? Even knowing, that it actually does not work if not in user 
context?

As far as the DO FUNC examples go, they are just equivalent to the 
LET examples, as is quite obvious. The distinctions are rather small, 
like the fact, that you do not need to create a function and then 
call DO

Clarity: That depends, because the example is contrieved as a "trap": 
I have little base for judging it.

contrived example - you never encountered a situation, when you wanted 
to keep the outside variable unharmed, using a local variable with 
the same name?

maybe not, it is not that frequent

the case would be that 'x is defined dynamically. I suppose I'm confused 
by the use of system/contexts/user/x. would you call the user context 
'x that way?

I am not sure I understand your question

just run the example in the interpreter

Nevermind. I think I can see it now. Regarding DO FUNC, I suppose 
the advantage should be less overhead with LET, if possible. Otherwise 
I see it as shuffling arguments around.

less overhead for the user (does not have to call DO), less overhead 
for the interpreter (does not have to create the function), and a 
couple more quirks like RETURN and EXIT handling

in essence, LET is the same as USE, just with the variables being 
initialized as needed

ok, it passes for me.

in R3, USE VARIABLES BODY is equivalent to LET VARIABLES NONE BODY, 
while in R2 USE VARIABLES BODY is equivalent to LET VARIABLES #[unset!] 
BODY

The BIND? function was added partly to deal with the security issues 
with R2's self. You can't as easily spoof BIND?.

on the question, why do we really need self:


self is very usefull when you use objects within code, because there 
can often be binding clashes.   self assures one that a parameter 
is always from the context and not from the function.

self.x: x


has occured pretty often for me.  its also very usefull when you 
need to return the context from which a function was bound.  
I also use it to do indirection: 

obj: self
context [
	parent: obj
]


remove self, and we can't say that REBOL has objects anymore.  many 
things will become really complicated for no reason.

Yes, I can understand, where the first one becomes handy, but it 
can be done easily in selfless contexts as follows:

[
    self: bind 'self
    ...
    self.x: x
]


The second one is actually more annoying having implicit self, than 
it would be otherwise:

[
   class- name: 'my-name
    context [
        parent: bind? class-name
    ]
]

sorry, I meant BIND? not BIND above

But, nevermind, take it just as a comparison...

yeah, but using bind is an inherently advanced use.  though like 
you, I understand that its just comparison.  


I'm in favor of 'SELF simply because I woudn't want REBOL code to 
become riddled with binds for such simple things. 


AFAIK bind doesn't scale well, in the sense that when you are playing 
around a lot with your code, bind will often become a point of failure, 
since the littlest change will quickly change what BIND does.

This is not BIND, just BIND?

(sorry again)

oooh... sorry I didn't see that nuance (my fault) ... I didn't even 
realize we had bind? in R3.   hum.  this opens up many doors.  I 
think my mind mistook every use of BIND? as a  call to  [ not not 
BIND? word].  

(like   found?  vs  find)

Same here...  BINDING? would work better, although longer

There was a long discussion about it a few years ago. I think it 
used to be BOUND? but that implies a LOGIC! result

I'd have gone with BINDING? too

Yeah. But it is still used in logic contexts, which is why BIND? 
returns true for function bindings.

(true or false, false meaning in fact the same as true, with a distinction, 
that the function is not running)

>> bind? do has [a] ['a]
== true
Nope, still bound.