World: r3wp

>> test: first ['foo]
== 'foo
>> lit-word? :test
== true

what happens Oldes if you do this:  

lit-word? 'test

And here?
>> get-word? :test
== false
>> type? :test
== lit-word!

>> val: first ['a]
== 'a
>> lit-word? val
== false
>> lit-word? :val
== true
>> lit-word? first ['a]
== true


It's not the assignment or LIT-WORD? that is converting the lit-word! 
to a word!, it is DO. This is a good thing.

It is not *in any way* a bug, it is intended behavior.

If you want DO to just get a value and not treat active values as 
values, use a get-word expression. This is evaluation model stuff. 
You need to be able to distinguish between the data that your code 
is working on, from the data that your code *is*, itself.

The difference is between your data:
>> ['a]
== ['a]
and the data of the DO function:
>> 'a
== a


Just because your code is data, doesn't mean your code is *your* 
data. It is actually DO's data, and DO interprets its data as what 
we think of as the REBOL syntax. I didn't see you complain that the 
set-word! in your code was treated as an assignment, or that the 
word! print is treated as a function call. The treatment of lit-word! 
values *in code* is no different from those.

This whole discussion belongs in the "I'm new" group, or maybe "Rebol 
School".

Brian, just for you information.  Remember that in REBOL 'test is 
not a lit-word.

Paul.. so you really think, that:
  get-word? :test
should return true? Because it's the same case.
Or what about:
  set-word? x:

Oldes, no I don't because words are the medium for data in REBOL.

Actually Oldes, I do believe they should be in your example.  But 
that is just me.

Paul .. Would you expect the argument to this function to be a lit-word 
or a word?

myfunc 'a

>> myfunc: func [word-or-lit-word] [print type? word-or-lit-word]

>> myfunc 'a

word

I suspect it would be a major change to Rebol for functions to receive 
unevaluated values which is what I believe you want.

I believe it would require much more than writing a native lit-word? 
function.

Perhaps when we get "plugins" or whatever they're called in Rebol 
3 will can experiment to find out.

It looks like what Paul wants is for lit-word? to take its argument 
literally. eg:

	*lit-word?: func ['val][lit-word? :val]
	*lit-word? 'hello ; == true


but this ends up causing problems, as discovered elsewhere with functions 
taking arguments literally, eg:

	my-val: first ['hello]

 *lit-word? my-val ; == false    <---------- Unexpected because MY-VAL 
 taken literally.

and


 *lit-word? first ['hello] ; == ['hello]     <----- Unexpected because 
 FIRST was not evaluated.

Paul, in REBOL 'test is a lit-word!. The problem is that you are 
getting datatypes and evaluation rules mixed up. When you are evaluating 
your own data, you can treat lit-words any way you like. When DO 
is evaluating *its* data (what you would call normal REBOL code), 
it treats lit-words as active values. Active values are normally 
evaluated when DO encounters them - the only exception is when they 
are just retrieved from some word they are assigned to, either using 
GET, or DO's shortcut for GET: get-words. All of DO's active values 
work this way.


And there is a good reason DO treats lit-words as active values: 
If there were no active lit-words, DO wouldn't be able to refer to 
word values without breaking words as variables, and normal REBOL 
code would cease to function.


When I say that it is not a bug that lit-words are active values, 
I am understating things. What is really the case is that lit-words 
being active values is the *entire reason for their existence* - 
if they weren't active values, there would be no point to them at 
all. Oh, and REBOL code wouldn't be able to work with its current 
syntax.

Anton you get it.  But in yoru second exampel it would be lit-word? 
:my-val since word is already defined.

Brian, my point is that 'test is NOT a lit word  as you can see here:

lit-word? 'test
==false

I have no beef with DO and how it works elsewhere.  Again, only how 
lit-word? and other functions work in that regard.

Try the lit-word 'test without running it through DO:
>> type? second [lit-word? 'test]
== lit-word!

Not my point Brian.  lit-word? says it isn't.

By the time LIT-WORD? sees the value, DO has already converted it 
to a word!, the way it is supposed to. LIT-WORD? works fine.

Anton must have read thru this because he narrowed down to the fact 
that I'm talking about what lit-word? returns when passed 'test as 
its argument.

LIT-WORD? is just a type test.

Brian, I don't care about what lit-word is actually doing.  I'm not 
trying to understand what it does.  I already get that part.  I'm 
saying it should be modified to identify 'test as a lit-word.

and 'test is a lit-word

You aren't passing 'test as an argument to LIT-WORD? whenn you do 
this:
lit-word? 'test
==false

What you are doing is *evaluating* 'test and then passing *that* 
value to LIT-WORD?. There's a difference.

No, lit-word? must be evaluating 'test.  nothing else is.

Trace it Brian.  The interpreter sees it as a lit-word.  It doesn't 
evaluate it to word!

DO is evaluating 'test. DO is the evaluator.

I'm not using 'DO

Yes you are, every time you run REBOL code.

Thats not true

IF runs DO, as does WHILE, EITHER, LOOP, ...

Functions do brian.  Which is my point that lit-word? could be modified 
to handle this.  You act like it can't be done.

Just because it doesn't show up in trace doesn't mean it doesn't 
happen.

Brian, if it was Do'ing the word then it would report back that it 
has no value when I do:

lit-word? 'test

Functions don't evaluate their arguments, the evaluator does. Your 
change to LIT-WORD? would break it. When you DO a lit-word! it returns 
the associated word! value. That is what lit-words mean in DO code: 
Literal words.

Just like DO treats set-words as shortcuts for SET, get-words as 
shortcuts for GET, etc.

Brian, my point is that I would rather have lit-word? do what it 
says it does.

It does that already.

Oh it does - does it?  Well let's check.

Tell me what datatype this is Brian:

'test

What context?  Is it being evaluated or now?

or not?*

Rebol from the command line, as well as a running script IS a 'do 
session, that's what we're trying to get at.  'do is what's converting 
the lit-word! into a word! before it reaches the function

Paul, when you write 

>>lit-word? 'test 

what is really happening is this: 

>>lit-word? ('test)