World: r3wp

That is especially important when working with list! datatype

Is it considered good practice to treat "none" as a false in a conditional 
expression?  I find that a little confusing, e.g. either find list 
value [truecondition] [falsecondition] ... what if "false" is an 
element in the list?

Hm, or for that matter, what if none is?

None! is not the same as false

Here is would be the difference Fork:
>> found? false
== true
>> found? none
== false

Ah, I see find returns a series, not a word.  Got it.

yes

I'm trying to wrap my head around the situation I'm concerned about 
but don't know quite how to say it, but it's something like: if [first 
find [false true] 'false] [print "False is the first element"]

>> if first find [false true] 'false [print "false is the first element"]
false is the first element

>> probe 1 = 0
false
== false
>> probe first find [false true] 'false
false
== false

>> pick [true "false is the element"] false
== "false is the element"

>> type? probe 1 = 0
false
== logic!
>> type?  probe first find [false true] 'false
false
== word!

Fork the false is being returned because it is the last value.

>> (1 = 0) = (first find [false true] 'false)
== false

in [false true], both are word! values, not logic!. If you want logic! 
values : logic! = first find reduce [false true] false

>> (1 = 0) = (first find reduce [false true] false)
== true

A ha

Is there a version of probe that prints the type also?

Not by default, but here's one : probe*: func [value][probe :value 
probe type? :value :value]

Dockimbel: very useful!

>> if 'hedgehog [print "hedgehog"]
hedgehog

Oh my.  Well, I think I'd rather define a "safe" if that only accepts 
true/false if there isn't such a thing

In REBOL everything is TRUE except false and none! values.

Btw, " favorite_fruit/set-value 'banana " doesn't look very rebolish 
to me...IMHO, REBOL way would be more like : " set-enum favorite_fruit 
'banana ". When you MAKE an object! in REBOL, all its functions are 
duplicated, so keeping the functions inside an object! and using 
it as in a class/instances model ends up eating a lot of memory. 
That's why the more "rebolish" way, where the code is out of the 
objects, is the way to go if you deal with a lot of instances (which 
might be the case for a "class" like enum!).  Remember that REBOL 
objects are prototype-based, meaning that they are created by cloning, 
not by instantiating a class. R3 will maybe bring us true class! 
datatype or at least a clean way to implement it by ourselves.

To check, if false is the first element:


>> if head? find [false true] 'false [print "false is the first element"]
false is the first element

>> if head? find [true false] 'false [print "false is the first element"]
== none

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  :)