Austin Hastings wrote:
In the C that I learned, the &^| ops were bitwise.
Likewise, the && || ops were lazy booleans.
So what's a single-letter boolean act like? Is it lazy? Does it retain
its bitwise-ness but (since boolean) force evaluation for 1 or 0 first?
I just don't understand what the "implied" behavior is, since the
reference is outside my experience.
Since they're producing a boolean result, both C<?&> and C<?|> could be
implemented lazily. However, I suspect they mightn't be, just to keep
them consistent (in their evaluation of operands) with the other bitwise
ops.
What's $a?
1 | 5 & 10
Yes (by precedence)
Umm, is this wrong?
Yep. Sorry.
(1|5) & 10
Yes (explcitly).
This one is still correct.
traits = any ( ... )
requirements = .. & ..
if $requirements eq $traits
Should that be traits = all()?
No. Because later we say (effectively):
print "True love\n"
if all(@desiderata) eq any(@traits)
In other words we want *all* the desired characteristics to be matched
by *some* trait. If the comparison was C<all(...) eq all(...)>, then
you're asking for every characteristic to be the same as every trait,
which obviously can't happen.
This is just a case where the "logic" of English phraseology has
several implicit assumptions that computational logic can't just
fudge over.
(In other words: Can you write Apoc.Flexible now, please?)
Well, I'd *like* to, but since that would involve giving up my first
vacation in two years, and consequently getting divorced...no.
;-)
Damian
