World: r3wp

When that context is used by FOR, I want 'self to not be bound. However, 
if the context persists after the FOR returns then I want BIND to 
do the 'self trick with any subsequent use of that same context; 
this is what I mean by "like a normal object context". - yes, and 
that is, where our POVs differ - similarly as Brian, I do not want 
one thing: I do not want Bind to behave differently when used twice, 
since it is not the right thing in my opinion - it means, that I 
cannot predict the behaviour of Bind unless I know the originator 
of the context. are there any other opinions, than mine and Brian's 
on this?

Brian does not want to Rebol to guess, but he actually forces it 
to do so - R3 now guesses, that you want to bind 'self, unless you 
say otherwise. In case of R2, that is not the case - Rebol does not 
guess, since it uses the context as defined by the user.

I changed my mind, self must absolutly remain in FOR loops (having 
context).
It allows rebolish tricky tricks in a nutshell.

See this one, I like it.

>> map-each [a b][1 2 3 4 5 6][copy self]
== [make object! [
        a: 1
        b: 2
    ] make object! [
        a: 3
        b: 4
    ] make object! [
        a: 5
        b: 6
    ]]

See, that is a counter-example :)

Steeve, put that in a comment in bug#1529. It's a good argument for 
keeping 'self binding for FOREACH, MAP-EACH and REMOVE-EACH, and 
then consistency would make us keep it in FOR and REPEAT as well.

Well, i think you will do a better explanation than me

Credit where credit is due. I can add an explanation later if you 
like. And I don't want it to seem like only Ladislav and I have opinions.

Are there any other opinions

: I think this boils down to what you want SELF to be. And I think, 
once SELF is easy to explain, you have found a good trade-off.

Ladislav, your suggestion to have some contexts not have the hidden 
'self in them at all is not what you think. You are suggesting that 
we create object! contexts (for that is what all contexts are except 
for function! contexts) that *can't* be specified by MAKE object! 
syntax, ever. And thus these objects will have an attribute that 
doesn't show up when you MOLD it (because MOLD generates MAKE object! 
syntax) that affects one of the core features of the BIND function. 
And that attribute wouldn't be serializable even if you added it 
to the MOLD/all syntax, because MOLD/all serialization of objects 
doesn't work: MOLD/all syntax for objects doesn't restore word bindings, 
only DO syntax does.

Posted, Brian

Thanks.

Brian, I think Ladislav wants objects and contexts to be separate 
things. This would most directly be modelled as two different datatypes, 
I guess: object! and context!. The former having the hidden 'self, 
the latter not.

Or perhaps he hates the idea of a hidden 'self field, and the corresponding 
BIND trick :)

Steeve, while this may be considered a nice trick, I don't think 
it's worth keeping the nasty self around.

map-each [a b] [1 2 3 4 5 6] [copy bind? 'a] does the same and is 
more explicit about what you want.

Andreas, you also make a good point. Please put that counter-counter-argument 
in a bug#1529 comment.

(The remark about increased readability of course only makes sense 
if you are accustomed to read bind? as "get-context" :)

yes but it's not an abstraction anymore.
if the words are changing, you must rewrite to action block

to -> the

Yes, but SELF shouldn't be there at all, it's only leaking through 
from the implementation.

Otherwise, SELF should also be there in all other contexts (pun intended)

I.e. I can make the same arguments regarding `apply closure [x] [self] 
[42]`, which behaves differently from the MAP-EACH example.

actually, it is everywhere.

I like the trick for conversion of records from fixed block spans 
to objects, both for Steeve's example and for passing along to functions 
that take object! records. However, as Andreas says we don't need 
the 'self binding trick to do it, we can use the bind? function.

(except in functions :)

Yep I agree, but mine is more Rebolish, that's all :)

It's not more rebolish if it is buggy.

It is rebolish, but the use case is more rare than regular usage 
of 'self to refer to the outer object context. And BIND? is also 
rebolish :)

Ignore that last remark, please.

Buggy ? what a word to say between gentleman

(My last remark, that is.)

lol

Actually, the BIND? trick works for all loop contexts but not for 
object contexts, which might have no fields. And it wouldn't work 
for closures with no parameters, but there is no point to those anyways 
so who cares :)

bind? is the new self :)

Except for objects, for the reason I mentioned above.

bind? 'self will work for objects, no :) ?

(Just kidding :)

Please bring up the BIND? trick in a comment to bug#1529.

These conversations in AltME are fun, but unless they are in blog 
comments, chat or CureCode they have no effect.

Yeah, I'll add a remark later on, but I gotta run now. Take care.

Carl is Altmeproof

There's too much here. He can't afford to read all of this crap. 
He needs someone to summarize for him, and to put it somewhere that 
won't scroll off the screen.

Ok, Andreas, I'll add it for you and attribute it to you. I'm working 
on this stuff now :)

Steeve, I couldn't find your comment in CureCode bug#1529. Where 
did you post it?

Sorry, i posted it on the blog

wrong place it seems

Yeah, we've played out the conversation there. Too many comments 
there already.

All right, fine, I'll post your code in CureCode and attribute it 
to you. And Andreas' code too.

...I cannot predict the behaviour of Bind unless I know the originator 
of the context.

 This seems like a core question to me. And while Steeve's example 
 is really neat, I wouldn't say it is REBOLish per se. BIND? doesn't 
 say a whole lot more, so I don't think either example is something 
 to hold up as a best practice. :-)


Is it by design? If so, how is it intended to be used, and how should 
it *not* be used? If not, what warnings do we need to include in 
docs?

Well, when you consider that MAKE closure! also originally did the 
'self trick and now doesn't, it appears to be accidental.