World: r3wp

it maybe seems odd at first sight, but consistent in the same way 
as this:

>> make-two: does [ 2 ]
>> make-two
== 2
>> function? make-two
== false

Paul, it is consinstent:

read first word - it's >lit-word?<
evaluate it - it's a function that takes one argument

read second word (first and only argument for that function) - it's 
>'test<
evaluate it - lit-word! evaulates to word!
pass it to the function - word! is passed, not lit-word!

Ok, if everyone else thinks so then this is one of those issues where 
its only me that thinks it isn't.  As long as newbies GET IT when 
learning REBOL that is what matters.

I am not so exp. rebol user as you but where do you use lit words 
as they are.. I used them only to pass words (reduced lit-words) 
basically so far ... in blocks never

 write  [  'some 'random 'words ]  but  [ some random words ]  as 
 they don't get evaled anyway

Paul: maybe you have a different usage pattern for them, so this 
behaviour that goes on looks odd/wrong when used that way?

yes Janko but that can be risking if they do get evaluated.  consider 
this [delete %/c/bootmgr]

See I read the documentation on lit-word? and it states:

Returns TRUE for lit-word values.

But you guys tell me that 'test is not a lit-word value.

That is what doesn't make sense to me.

yes, I get this delete example :) good point ,... I would have to 
look in what manner I used blocks with "random" words (if I did) 
to see what could happen..  I did some when I was playing with dialects.. 
and to store data in [ key "value" ]  manner

is make-two a function ? it is but when you write it it gets evaled 
to 2 and if you write >>function? make-two<< you get false , same 
here it is but it get's evaled to word

But 'test is a value - not a function.  It is the end value as I 
call it.  In other words it doesn't evaluate.

words can evalute but lit words don't.

no, lit words evaluate to words

I know it does which is why I believe that is inconsistent.

I currently get this:

type? 'test
==word!

I think it would be more consistent to get this:

type? 'test
==lit-word!

Consider this link by Brett:

http://www.codeconscious.com/rebol/articles/rebol-concepts.html

It says the following:

'age

This textual form is recognised in rebol as the lit-word! datatype.

See that isn't entirely true - only half true.  Consider:

>> lit-word? 'age
== false

But this is purpose of lit-word! With your behaviour,
>> reduce ['a] ; would return
== ['a]

But that makes sense to me.

That is why I say that it is only half true to say that it evaluates 
to a lit-word.

It does sometimes but not all the time.

No, it evaluates to word!, not lit-word!

Always

To me that is the inconsistency.

Paul, with your behaviour, how would you write this code?:

>> a: 3
== 3
>> reduce ['a a]
== [a 3]

to me it should be ['a 3]

But I know that  breaks how REBOL works.

but then 'a would be very similar to just string "a" in behaviour... 
don't lit words exist exactly for the behaviour that they have?

And REBOL does see 'test as a lit-word.  A trace shows this:

>> string? 'test
Trace:  string? (word)
Trace:  'test (lit-word)
Result: false (logic)
== false

Yes Janko, it would be intended in that behavior which again is why 
it would break how REBOL works.

Does this help?  X contains the code you see and type, the lit-word! 
typed in.  It gets reduced to its word value..
>> X: [type? 'one]
== [type? 'one]
>> type? X/2
== lit-word!
>> do X
== word!

I'm not arguing about how lit-words are used.  I'm arguing about 
how lit-word? detects lit-word.

The rest is understood that it should work they way it should be 
cause of the manner of words in REBOL.  But the function of lit-word? 
is what to me seems inconsistent.

I understand all of that IzKata.  I have been using REBOL since 1998 
now.

That part has remained pretty much the same.

My argument lies specifically with the lit-word? function.

What is wrong in having lit-word? return True in this case:

lit-word? 'test
==true

but argument to lit-word? in your case is not lit word , it can't 
return true vithout magic 

>> 'test
== test (this is what lit-word? recieves in)

Yes it is Janko, a TRACE shows that my argument  is a lit-word.

If you were correct Janko then how would Trace know to classify my 
argument as a lit-word?

how do you make this trace (I never used it, and also don't understand 
what exactly it shows)

Trace shows what the rebol interpreter first finds, not what a datatype 
evaluates to:
>> type? 'test
Trace:  type? (word)
Trace:  'test (lit-word)
Result: (datatype)
== word!

Janko:
>> trace on
Result: (unset)
>> 'test
Trace:  'test (lit-word)
== test

Yes Izkata, it finds that 'test is a lit-word.

And the interpreter converts it to a word! before passing it to 'lit-word?

so lit-word? never sees a lit-word!

Yes, I understand that.  But that is not what it was given.

Again, I'm saying what is wrong with having the lit-word? function 
return true for a lit-word value?

Obviously the interpreter can see that it is a lit-word value even 
BEFORE it calls it a word! value.