World: r3wp

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.

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.