--- Michael Lazzaro <[EMAIL PROTECTED]> wrote: > > One thing we should clear up is that we already *have* a generic > comparator, C<~~>, depending on what you mean by "generic". It can > be > made to compare things however you like, according to whatever > standard > of similarness you decide you want to enforce, and can even compare > objects of disparate types (if you tell it how.) > > The way I personally have been envisioning this working is: > > $a == $b; # compares numerifications of $a and $b > $a eq $b; # compares stringifications of $a and $b > $a ~~ $b; # tests equality of $a and $b > $a =:= $b; # tests identity of $a and $b > > Of these, I would expect that ==, eq, and =:= would almost never be > overloaded, because they have very specific meanings.[*] > > You _could_ choose to override those == and eq for a particular > custom > class, and use those for comparing equality of objects. But since > some > people will tend to want to override ==, and some will want to > override > eq, it's not clear that the Perl6 community will converge on using > only > one or the other, which might make things quite confusing if you're > using a library that has standardized on the opposite convention from > > your own. > > ~~, on the other hand, is meant to be overloaded to a > possibly-excruciating extent, and I've been assuming that it will be > the thing that classes most often overload when they want to test > "equality" of two arbitrary objects, without resorting to serializing > > them via num/str. (Using num/str comparisions to test for object > equality obviously only works if num/stringifying _completely_ > serializes the object -- which very often is _not_ what you want the > num/stringification of an object to do, by default.) > > The proposed =:=, however, merely tests that two objects are > identical > -- that is, _that they are bound to the same underlying thing_. It's > > possible for two objects to be equal, ~~wise, without actually being > identical, identitywise. I don't see ever wanting to overload =:=, > and > it's unclear if it should even be allowed.
It has been pointed out once already that we already talked about this, and I for one am in favor of the general version of it. The original discussion posited an "adverbial comparison", viz: C<$a eq:ref $b>. Which, looking at your proposal, is very close to C<$a =:= $b>, because I'm reading that as "equals, under assignment". Likewise, I could argue that it be called C<=:\> (the "disgruntled muppet" operator?) since that reflects the "equals, under reference" symbology. But that's yucky. So: I believe that adverbial comparisons are desirable, and in fact believe that arbitrary-sub comparisons are desirable, provided they don't cost much. sub budgetwise(Int $a, Int $b) { -1_000_000 <= $a - $b <= 1_000_000; } my Int $log_rolling, Int $pork_barrel; $log_rolling = random() * 1.0E9; $pork_barrel = random() * 1.0E9; if ($log_rolling eq:budgetwise $pork_barrel) print "They cost the same, give or take a million dollars."; > Note also that == and eq comparisions are naturally accompanied by > greater-than, less-than variants. But ~~ and =:= don't really have > those variants, because they wouldn't make much sense. Even inverted comparisons are suspect in junctionville. > Having said all that, it should be noted that I'm completely making > this stuff up. Finest kind.