HaloO,
Larry Wall wrote:
On Wed, Oct 26, 2005 at 04:56:23PM -0600, Luke Palmer wrote:
: > Then ^T $x binds T to the kind of $x. And $x.kind == $y.kind asks
: > if two objects are of the same type,
:
: Don't you mean $x.kind eqv $y.kind?
I start to dislike the eqv name as generic value comparator because
it looks too much like the dual of xor. And there is the numeric
comparator <=> and its string companion cmp. But I don't want to re-open
the settled discussion of the operator names. OTOH, we could use the Num
kind as the prime representative of things that provide ==, !=, <=, >=,
<, > and <=>. Actually != is a bit odd there, but I guess no one would
accept <> even if it were available. But then keeping the ! logical negation
indicator we could use !< and !> instead of >= and <= respectively.
This is not too bad linguistically if we define
< below !< not below # >= is an alias
> above !> not above # <= is an alias
== equal =!= not equal
= equal != not equal # this one is just too beautiful
# to become Perl6 reality :)
and the string counter parts
lt < ge !lt !<
gt > le !gt !>
eq == ne !eq =!=
Thus logical negation becomes a meta prefix operator like
meta postfix = deals with infix ops. The unless conditional
form then means exactly the same as outer logical negation
if $x != $y {...}
if !($x == $y) {...} # same, also with space: ! (...)
unless $x == $y {...} # same
if $x not == $y {...} # same
if not($x == $y) {...} # same, also with space: not (...)
if ($x == $y).not {...} # same, method form
As a side effect the junctive annoyance
if $x != any(1,2,3) {...}
automagically becomes
if !($x == any(1,2,3)) {...}
The in-place modification unary method form then is $x.=not and might
have an optional boolean argument whose negated form becomes the new
boolean property. So $x.=not(0) means '$x becomes not false'. With bit
beeing an abbreviation of 'be it' just as not means 'no true' this can
be spelled $x.=bit(1) and read '$x becomes be it true' or some such.
If the Num kind models the mathematical ideal of real numbers then
$x == $y is synonym to false and $x != $y to true almost always. Anyone
doing numerics knows that you should actually use abs($x - $y) < $eps.
With $eps == 1 you get the integer case. Implementing Num as Int+Rem
where 0 !> Rem < 1 the Int comparison would be spelled
$x ==:rem(0) $y
or perhaps better looking as
$x == $y :rem(0)
or
$x ==:int $y
Note that there is a slight difference to $x ==:eps(1.0) $y which is true
for $x = 3.8 and $y = 4.2 because their delta is 0.4 while 3 < 4 intwise.
The default fall-back in case of $x and $y beeing actual non-int nums could
use e.g. :eps(1e-6) which of course is configurable via pragma
use Num:eps(1e-10);
The spelled out forms might read
$x equal:int $y # infix form
$x.equal( :int, $y ) # method form
equal :int, $x, $y; # listop form
and correspondingly
$x below:int $y # infix form
$x.below( :int, $y ) # method form
below :int, $x, $y; # listop form
This logical negation idea could even be driven further
// err /!/ nerr
|| or |!| nor
&& and &!& nand
^^ xor ^!^ nxor eqv
The same can be done with the equality/identity checkers
where the intended concept is indicated by something between
the two = chars
== generic num-like equality =!= generic num-like inequality
=:= referential identity
=::= symbol identity
=^= kind identity
= value copy
:= referential binding
::= symbol binding
and perhaps something like
<::< type below
>::> type above
^< kind below # or: <^ <^= <^<
^> kind above
Now that infix:<::> has come available, maybe I mean:
$x.kind :: $y.kind
Well or
$x =^= $y
and also
^$x == ^$y
Sorry, couldn't resist.
--
