World: r3wp

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.

A gave the link because the one on my computer actually has the == 
symbol  instead.

I will probably update the website one later.  Still testing some 
other modifications to the function.

>> a: 'test
== test
>> :a == make lit-word! :a
== false
>> :a = make lit-word! :a
== true

Doc, the problem is that Paul never actually passes a lit-word to 
the function, so he can't test for strict-equal?. It just happens 
to work the way he wants for lit-words.

>> as-lit-word? 'test
== true

See doc - that is with the strict equal.

What does mean the resulting value of as-lit-word? That no error 
happened? What's the point?

gotta call in for unemployment be back in awhile depending on when 
i get thru on the phone.

Henrik: yeah I see now what's he is doing. The function just returns 
true for word! values passed as argument. I still don't see the point...looks 
like Paul is chasing windmills.

Paul, in your examples : as-lit-word? test is equal to : as-lit-word? 
1. Functions arguments are evaluated before the function is called 
 except if the functions arguments are defined as lit-word! in the 
specification block.

Paul, your LIT-WORD? function returns true if passed a word! value, 
which breaks it.

>> a: 'test
== test
>> type? a
== word!
>> type? :a
== word!
>> a: to lit-word! 'test
== 'test
>> type? a              
== word!
>> type? :a             
== lit-word!

As I see it, 'test gets evaluated to a word.

LIT-WORD? needs to return false for values of other word types. That 
is its job.