World: r3wp

As for #1434 (and your most recent code example), I would prefer 
to have lit-words and lit-paths be consistently active values (the 
way lit-words are in R3 now) for the same reasons you proposed #1881 
and #1882. This means having them convert to word and path when they 
are evaluated instead of just gotten. But if you would prefer them 
to be a special case like parens (the way lit-paths are in R3 now), 
that would work for me too as long as that is the case for both lit-words 
and lit-paths - it would make them a little easier to work with.

I'd prefer lit words to be "dead", its so much pain to preserve lit-words 
within datasets.  I've often had "word has no value" errors when 
building data blocks for dialects or datasets which are being manipulated 
one way or another .

I meant the "you" in "if you would prefer" to be the collective "you", 
the consensus opinion, not necessarily that of you in particular, 
Ladislav :)

;-)

If lit-words are turned into a special case, being otherwise inactive 
(like lit-paths are now), that would work for me. Though normally 
we would want lit-words to be converted to words, if the #1882 change 
to word evaluation goes through, that would mean that lit-words could 
change to words which could execute functions. If that kind of thing 
could happen, I would rather it happen through explicit conversions 
so you can see it in the code.

in #1434 I did not say anything about my preferences

I just asked whether a note about "incosistency" contained in there 
was appropriate

not to mention, that the example here is not the example in #1434

I guess I had trouble parsing this sentence:

I do *not* propose the result of 

do quote 'a 

to be a lit-word, 
since the word really looks reasonable to me.


That seemed to be a preference for lit-words converting to words 
in that case, though I may have misinterpreted that.

in my opinion, the behaviour of

    do quote 'a

expression is something else than the behaviour of the

    lit-word: first ['a]
    do [type? lit-word]

example

Whether or not there is going to be a difference between inline evaluation 
of lit-words and evaluation of lit-word values, evaluation of lit-word 
values needs to be consistent whether you do so by referring to them 
with an inline word, or through explicit DO. R2's behavior is a bug.

The choice is between having behavior like what R3's lit-words do 
now (fully active), or what R3's lit-paths do now (special case for 
inline evaluation, otherwise inactive).

Once again that "consistent" word. There is the main difference. 
I do not think you can call "inconsistency" any difference in the 
evaluation of the former and the latter expression, since the former 
expression is about handling lit-words as arguments of the DO function, 
while the latter is about handling words as inline block values, 
when they refer to lit-words.

I've been using the terms inline evaluation for having the value 
inline in the code, regular evaluation for when the value is referred 
to through an inline word, and explicit evaluation for when the value 
is passed to DO directly. If the first is to be different, the latter 
two need to be consistent with each other, same as with parens.

I intendedly coined the terms

active value

 to refer to a value that when encountered inline in a block does 
 not evaluate to itself
word-active value
 to refer to how a word is evaluated when referring to a value

These two cannot be "consistent" nor "inconsistent"

for example, parens are active, but they are word-inactive

(which is conveinient)

OK. There is stuff like functions, and these are called "active values" 
- they behave consistently for inline, regular or explicit evaluation. 
There is stuff like parens, which behave one way for inline, and 
a different way for regular or explicit evaluation - what term would 
you like to use to refer to this pattern with? Because those are 
the only two choices that would make sense with lit-words and lit-paths.

Maxim apparently prefers that lit-words and lit-paths act like parens, 
and so does Geomol. I would be OK with that model.

I prefer that as well

Then please say so in a comment to #1434, so we can have a consensus 
recorded :)

OK, I will try

Then I can change the "should be" comments in the ticket example 
code accordingly :)

The proposed model is something like this:
>> 'a/1 
== a/1 ; inline evaluation of lit-path converts to path 
>> b: quote 'a/1 
== 'a/1 
>> b 

== 'a/1 ; regular evaluation of lit-path value does not convert to 
path 
>> do :b 

== 'a/1 ; explicit evaluation of lit-path value does not convert 
to path


So it's not exactly like parens, but it's what Maxim, Geomol and 
I would prefer.

Your terminology:

inline evaluation
regular evaluation
and
explicit evaluation


is acceptable for me (although I am not sure about the "regular evaluation", 
isn't there a chance to find a better notion?)

I hope so - that term seems to need too much explanation.

how about "indirect evaluation"?

implicit?

(there is a level of idirection, since an evaluated word refers to 
a value)

so, my preferred would be "indirect evaluation"

But, again, we actually can see two kinds of indirect evaluation:

Inline indirect evaluation
, or "explicit indirect evaluation"

Sure. The reason I called it "regular" is because a word! has no 
markings, either in terms of characters added to the syntax, or qualifiers 
added to the type name. This implies that word! evaluation is the 
default, or the regular style, while the others are exceptional.

:a evaluation is inline too, so "inline indirect evaluation" could 
apply to that.

Why I hesitated to write my preferences regarding indirect evaluation 
of lit-words was, that I felt the #1434 ticket was more about the 
explicit evaluation

The #1434 ticket is about making lit-word and lit-path consistent 
with each other, and about documenting some of the intentional changes 
from R2.

Are you OK with this, Ladislav?
>> 'a/1 
== a/1 
>> b: quote 'a/1  b 
== 'a/1 
>> do quote 'a/1 
== 'a/1

Or do you require this?
>> do quote 'a/1 
== a/1

Yes, but the summary says "DO evaluation...", which, for me, means 
either "inline evaluation", or "explicit evaluation".

All of this evaluation is done with DO. The question is *how* it 
is done with DO.

OK, nevermind. I prefer

    do quote 'a/1

to yield

    == a/1

to be honest

As long as that is documented, I would be OK with that too. Geomol? 
Maxim?

, i.e. I see a greater difference between direct and indirect evaluation, 
than between inline and explicit evaluation.

Then you can put your preferred behavior model (with that i.e. justification) 
in your comment, and we can get a consensus there through people 
agreeing with you. This would be the code:

>> 'a
== a
>> b: quote 'a  b
== 'a 
>> do quote 'a
== a
>> 'a/1
== a/1 
>> b: quote 'a/1  b
== 'a/1 
>> do quote 'a/1
== a/1

I will write it, removing the older (and maybe misleading) comments

Cool (because I definitely misunderstood that last comment).

one more question (I guess, that a kind of glossary may be of use). 
How about replacing the "explicit evaluation" by "immediate evaluation" 
to contrast it more with the "inline evaluation"?

may not be ideal, just wondering whether we could find something 
which would be obvious to be opposite of "inline"

I meant explicitly calling DO. The other two styles of evaluation 
are usually the result of calling DO implicitly (through function 
evaluation, IF, etc.).

All of those forns of evaluation are done by calling DO in one way 
or another.

OK, nevermind, I shall use "explicit evaluation" for now