World: r3wp

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)

Paul, I agree with everything BrianH has said in this discussion.

When, you've typed something at the console:

	>> 'test	

, and you press Enter, it is as if this is happening in a script:

	do ['test]


The result is equivalent - a lit-word reduces to a word, which is 
returned.

yes, and
>> lit-word? 'a
can be written as
>> do lit-word? do 'a
or 
>> (lit-word? ('a))

As I said guys it is just me that doesn't like how it lit-word? operates.

As I said before I know what is happening but rather it didn't happen 
that way.

I wonder how you would make it work like you want, because that is 
up to the interpreter, not LIT-WORD?.

>> a: func [b [lit-word!]][return b]
>> a 'test
** Script Error: a expected b argument of type: lit-word
** Near: a 'test

I made one that works like I want and it doesn't use lit-word? at 
all

>> is-lit-word? 'test
== true
>> is-lit-word? first ['test]
== true
>> is-lit-word? "test"
== false
>> is-lit-word? 'do
== true

what happens with "is-lit-word? first [test]"  ?

That would be true also.

>> is-lit-word? first [test]
== true

See to me the question comes down to the fact that I wanted a function 
that tells me what the argument was passed to it as not what the 
function recognizes it as.

So then I have to determine what is a lit-word?  It is merely a word 
that is has the tick symbol at the beginning or is it a word that 
in affect is of the same characteristic as a word with a tick symbol. 
 I chose the latter since it is more in form with REBOL.

http://www.tretbase.com/forum/viewtopic.php?f=8&t=30&p=141#p141

So.. it looks to me like this is just what you wanted:  any [word? 
val  lit-word? val]
Is it, or does is-lit-word? do something I'm missing?

Almost does.  I fixed it up a bit for you to give you more of a match 
to my function here:


 a: func [val][if any [word? val lit-word? val][return true] false]

However, you used lit-word? which was what I was avoiding.

I would have to look at it much more to see how closely it matches 
but via the test posted here it seems to work.

Nope yours doesn't do exactly what I wanted.

Works for most cases but some important ones it fails on.

>> a first reduce [to-word "test"]
== true
>> as-lit-word? reduce [to-word "test"]
== false

>> a first reduce [to-word "test"]                               
    
== true
>> as-lit-word? first reduce [to-word "test"]
== true
>> a reduce [to-word "test"]      
== false
>> as-lit-word? reduce [to-word "test"]
== false

oh - lol

I forgot the first.

actually it would be correct in both cases as it would still be a 
block.

Here you go:

>> c: make set-word! 'd
== d:
>> c
== d:
>> a c
== false
>> as-lit-word? c
== true

My function shows that BrianH was wrong.

And many agreed with him are wrong also.

Paul, I have a hard time following the discussion. Can you show what 
you are right about?

Sure henrik.

Here is what BrianH said:


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.

Obviously that isn't true as my function shows.

Brian is saying that 'test would get evaluated to a word and *THAT* 
value is then in turn passed to lit-word? function.  But that isn't 
the case.  Because if it was indeed a word! at that point then there 
is no way my function could detect it as a lit-word!

what was the source for as-lit-word? again?

http://www.tretbase.com/forum/viewtopic.php?f=8&t=30&p=141#p141

as-lit-word?: make function! [  

    "Returns logic on whether the val argument is as a lit-word! type"
    val
    ][
    not error? try [= :val make lit-word! :val]
]

You're using the wrong operator, your should be using == instead 
of = to test for datatype equality.

not error? try [== :val make lit-word! :val]

You can use that also Doc and it still works.

I have already used both in my function.