World: r3wp

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.

Agree.

And that is what it does, right? So no problem there?

back.  ok it only took like 35 redial attempts to get through the 
Illinois unemployment claims service this week - unbelievable.