World: r3wp

I always use AND, OR and XOR in both their logical and bitwise sense. 
There is no confusion because I have to use logic! values for the 
logical behavior. This means that explicit conversions resolve the 
difference visibly.

but brian, the current AND/OR/XOR  *cannot* be used for logical ops. 
 the fact that none isnt' supported is the proof that its not working. 
  bitwise ops already exist in principle with the "set" functions 
 'complement, 'union etc.

Bitwise ops are computerish, logical ops are how humans think. I 
don't mind making the bitwise alternatives a little more verbose, 
or even adding a dialected BITWISE function.

I use the term "conditional expressions" for the truthy/falsey expressions, 
and "logical expressions" for the logic!-only ones, not interchangeably.

But, as Max brought up again, teh set ops are already there.

Ah, I see Brian. I'll try to remember that.

TRUE? was designed to convert a conditional expression to a logical 
expression. I think it used to say that in its docstring.

Anyway, vote on Ladislav's proposal. I'm a +1.

but in real life 'TRUE? is ugly, it makes code hard to understand 
and it forces us to use parens everywhere.... oh and it slows down 
code too.

sorry, but I can't fathom this:
if ((true? value) AND (true? value2)) OR (true? value3) []

this is how it should be:
if value AND value2 OR value3 []

(I'll shut up now  ;-)

There are similar conversions from is-it-zero-or-not to logical, 
from is-it-found-or-not to logical, from is-it-empty-or-not to logical. 
The conditional one isn't different. It is interesting that we don't 
have conditional AND, OR and XOR, but not really bad because of all 
the methods of explicitly converting to logical.

Brian, is it an intention, that you don't mention NOT?

NOT is conditional in REBOL, so it doesn't have the same constraints 
as AND, OR and XOR which are logical or bitwise, depending on the 
types of their arguments.

that's an unary logic! op!; hence a black sheep :)

Nice one, Tamas!

If you want to make logical versions of AND, OR and XOR separate 
from their bitwise versions, that doesn't make any sense - their 
types already distinguish them. If you want to change AND, OR and 
XOR to be contitional, then the additional ops can behave like the 
current ops behavior: bitwise or logical, depending on argument types.

contitional -> conditional

OK, reading the Brian's formulations, a different expression of the 
poll question might be: "Do you, REBOL users, want to have 'combined' 
logic and bitwise' binary operators, wouldn't you prefer the operators 
to be conditional?"

(NOT could also be bitwise; if u ask a hardware guy...)

Sure, but that is not the question here, the question should be what 
do you prefer.

If they are conditional (it would have to be including NOT), then 
the additional bitwise operators would be able to treat logic! values 
as if they were one bit.

onetom, we already have the bitwise not... its called complement 
 :-)

I would use the weird characters for the bitwise ops and the words 
for the logical ops. Maybe we could have ! be the same as COMPLEMENT 
instead of NOT.

words for the conditional ops, I mean

understood

brian, logic values IMHO should be "all on" or "all off", which is 
what I'd prefer, its also more complementary,  as in 

not value or this-one

what'd you think?

I mean, NOT would be the conditional not, and COMPLEMENT is the bitwise/logical 
not, same as now.

What if we write a C dialect in REBOL, and confine all support for 
[! | & || &&  >> <<] ops to that? ;-)

Logic and conditional values are all-or-not. Only bitwise is partial. 
For the one-bit logic! values, there's no difference.

I would probably vote for Ladislav's proposal if I knew which words 
were to be used for logical AND,OR etc. and which wold be used for 
bitwise.


For me, there is a clear advantage of additional clarity gained with 
separate  functions. I am not clear on the disadvantages (if any) 
of keeping them as single functions.

less words to learn and search in the dictionary.

the whole type system tries to build on this principle, so words 
can behave according to their context, just like in natural languages.

Peter, you may not have noticed, but I proposed all of the NOT, AND, 
and OR operators to be conditional. Their non-conditional counterparts 
already exist, and can be used for all the other purposes: COMPLEMENT 
(already not needing any change at all), INTERSECT (would need to 
add datatypes like LOGIC!, INTEGER!, CHAR!, TUPLE!, ...) and UNION 
(would need to add the datatypes like INTERSECT)

So, no new operators.

and in fact XOR is the infamous ALTER.

Sorry Max, not at all.

ALTER is a modifying function.

yeah... tought about it and I was going to say... forget it.

modifying or not, its not doing the same thing anyways.

so I guess we only have to find an new function name for XOR's bitwise 
variant?

DIFFERENCE

ah, sorry, it would need to be the COMPLEMENT DIFFERENCE

or not, I confused it.

no it seems to work perfectly.  I just tried it.

(on blocks at least)

>> a: [1 2 3 4] b: [1 2 3 5]
== [1 2 3 5]
>> difference a b
== [4 5]

is exacty what I would expect of XOR on blocks.

>> difference make typeset! [none! unset! integer!] make typeset! 
[decimal! inte
ger! tuple!]
== make typeset! [unset! none! decimal! tuple!]


>> xor~ make typeset! [none! unset! integer!] make typeset! [decimal! 
integer! t
uple!]
== make typeset! [unset! none! decimal! tuple!]

So, yes, it should be DIFFERENCE

less words to learn and search in the dictionary.
the whole type 
system tries to build on this principle, so words can behave according 
to their context, just like in natural languages.

Agreed, this is key

I feel a little confused. Are you proposing that DIFFERENCE be used 
for bitwise XOR?

So logically:

>> (#"^(40)" xor #"^(C0)") = (difference #"^(40)" #"^(C0)")