World: r3wp

Geomol: good point... that wasn't what I was doing, the quote should 
have been "false is in the list"  :)

Dockimbel: That's quite good to know, thank you, I will make that 
change.

It was a quick ping-pong up there, so I'm not sure, if you know the 
answer, but to find false in a series:

>> if find [false true] 'false [print "false is in the list"]
false is in the list

And you know, this isn't the value FALSE, it's just words.

To check for the logic! value FALSE, you have to reduce the block:


>> if find reduce [false true] false [print "The logic! value false 
is in the series"]
The logic! value false is in the series

>> if find reduce ['false true] false [print "The logic! value false 
is in the series"]
== none

>> if ( reduce first find [false true] 'false ) [print "false is 
in the list"]
false is in the list

I'm looking for how to make first find [false true] 'false NOT print 
false is in the list

As per my usual question method, if y is ( reduce first find [false 
true] 'false )... what is f(y) to make that happen :)

because FALSE there is a word!, not  logic!.

>> first find [false true] 'false
== false
>> type? reduce first find [false true] 'false
== word!

That much I get, I just thought that reduce turned false-as-word 
into false-as-logic and it does not

Yes, it's still a word! and not a logic!, even if you reduce it.

So what turns it into a logic, if not reduce?

do

reduce the block instead

>> if ( do first find [false true] 'false ) [print "false is in the 
list"]
== none

looks like R3 does not exhibit that behavior. it's reduced to logic!

Ok, great, that's the case I was worried about then...

Or LOAD:
>> load to string! 'false
== false

I'm confused as to why reduce, which seems to perform other evaluations, 
would not (in R2) turn false into a logic!... Henrik, you are saying 
it does?

Fork, Rebol 3 does, so this may be an inconsistency in Rebol 2.

It's often works, if you turn stuff into a string and then load that. 
Other ways to turn stuff into strings:

>> load mold 'false
== false
>> load form 'false
== false

*It* often works ...

Not quite;    reduce 'false  is a word,  reduces as a word!     reduce 
[false]   reduces the block, evaluating false to the logic! false. 
  It's fun stuff.   ;)    mold/all  can be your friend exploring 
the ins and outs of evaluated values.

oops! :D

Sorry John; responding to Forks confused post not yours.   I always 
trust Geomol advice  :)

I got confused too. :)) REBOL is funny to play with!

>> type? load form 'false
== word!
>> type? load mold 'false
== word!

In R2, REDUCE main purpose is to reduce block! values. For general 
evaluation use DO.

btiffin, I make mistakes too! :-)

Yeah any word! reduced is still the word!

sorry:

>> type? false
== logic!
>> type? reduce false
== logic!

R2 and R3 behave identically here.

Henrik, yes, but
>> type? reduce 'false
== word!

Is that the same in R3?

It seems like reduce is a core notion, and it would be nice to see 
a list mapping what conversions it performs.  Changing that between 
R2 and R3 seems rather... fundamental?

Fork;   There are also "lexical forms" for all these values.   #[false] 
 is loaded by REBOL as the logic! value false.  No need to evaluate 
in that case.

John; yes.

I'd suggest coming up with a new keyword, e.g. reduce3, if something 
like that were to change.

geomol, yes, they are identical

Fork, we're normally ok with not being completely compatible with 
new versions. Better to correct the failures as soon as possible.

Brian;   It comes down to the ill-documented sequence of  load/evaluate 
and the spellings of some the values.  false, true, none are the 
most common gotchas.

Fork, R3 is not meant to be compatible with R2, so that would not 
be likely to happen. If a function doesn't behave consistently, it 
will change. Just for the record. :-)

Alternative:

>> type? do load form 'false
== logic!

But the most simple must be:
>> type? do 'false
== logic!

There are so many ways to get the same result.

Ok, I appreciate the help... but I do wonder if there is a certain 
answer that Rebol 3 reduces words to logic

So my earlier example, would it act different in R3?

>> if ( reduce first find [false true] 'false ) [print "false is 
in the list"]
false is in the list

Nope;  words reduce as words.

Here is a good article by one of heroes;   http://en.wikibooks.org/wiki/REBOL_Programming/Advanced/Interpreter

same result

and it would be because we are in that example always dealing with 
words.

Ok, so Henrik, does that mean you retract your statement "Fork, Rebol 
3 does, so this may be an inconsistency in Rebol 2."

yes :-) sorry about that. I mixed up some results.

In regards to what I said: "Im confused as to why reduce, which seems 
to perform other evaluations, would not (in R2) turn false into a 
logic!... Henrik, you are saying it does?"

Ok, whew.  Good :)

Give Ladislav's article a read...it cleared up a lot for me, but 
I still can't explain it  :)