World: r3wp

If it did, then I would think that Trace woudl show that but it doesn't 
- again:

>> 'test
Trace:  'test (lit-word)
== test

nothing about it being word! in that trace.

Exactly, trace doesn't show that.  Trace doesn't show everything.

Well then how can we be sure that is the case?

>> Gettype: func [A][print type? A  return A]
>> lit-word? Gettype 'Test                   
word
== false

In other words how do we not know that the native lit-word? function 
couldn't be modified to in fact report true in this case?

Unless large modifications are made to the language itself, it would 
also start returning true for regular word! values

Well that is my Izkata, how do we know that - are we just assuming 
that?  I mean we know that it can handle the data as a lit-word while 
it is in an unevaluated block.

For example, why can first ['test] return lit-word then?

Surely we can return true with a modification to lit-word? function 
to do the same for lit-word? 'test

Izkata, let my pose a hypothetical question to you.  If lit-word? 
could return TRUE to this statement:

lit-word? 'test

Would you desire that ability?

No, as I would then never know if something's datatype was a word! 
or a lit-word!

sure you would.  a word that doesn't have the tick in front of it 
woudl be a word!

No

first is function! that gets evaluated. it takes one argument - block! 
that argument is also evaluated and block! is evaluated to block!. 
then it returns first value of that block. this value is not evaluated 
- but that's ok, it's 'first's behaviour

But it's better to submit it as a wish into CureCore and see what 
Carl means

Oldes I was going to personally take it to Carl via RebDev but I 
won't if the community doesn't desire it to report true in such a 
case.

Paul, how would you check that?  String manipulation?  Because trying 
to get the first character of a word! or a lit-word! errors

Izkata, how does REBOL know that this is a string?:

this

Without a context, it doesn't:
>> X: to-word {"this"}
== "this"
>> ? X
X is a word of value: "this"

:)

Izkata, I'm sure that REBOL is written in C language and in C we 
use a char type for this.  So it is possible to detect the ' character.

Why do you need this behaviour?

Just seems more consistent to me Oldes that is all.

>> 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.