I mean, it's nice that this sort of functionality has nice and concise operators, but I'm coming from a school of thought where overloading the equality operator should not be done lightly :)
Each operator and its overloads -- certainly built ins, users are recommended to follow suit -- conceptually maintains its own single high level semantics. Thus, while some langs have a `+` op that does numeric addition or string concat based on operand types, in Perl 6 a `+` will always mean numeric addition (unless a user breaks this convention).
`==` is always numeric value equality.
`==` does what most folk would expect between any pair of values that are a subclass of Any (the root of the type hierarchy for most purposes).
Junction is a direct subclass of Mu (the ultimate root of the type hierarchy), outside the Any hierarchy.
When a scalar operation is applied to one or more Junction values, the relevant operation is "autothreaded" over the superposed values inside the Junctions and returns a new Junction value.
If a Junction is treated as a boolean the Junction collapses to a regular single boolean value.
Junctions seem way more complex than that, first there are 4 different junction contains (any, all, one and none), second they overload 12 comparison operators each and third the other operand doesn't have to be a junction.
So e.g. any(@ar1) == any(@ar2) is an intersection but any(@ar1) == $val is a containment, and I've no idea what all(@ar1) < any(@ar2) would be, I guess it would check that max(ar1) < max(ar2)?
junction1 = val1 | val2 | val3;
junction2 = val4 & val5;
if junction1 op junction2 { ... };
* Makes $x == 5|6 look kinda cool
* $string ~~ /<first>/ & /<second>/ & /<third>/ # matches all three regexes. huh. kinda cool
* (5|6).foo maybe we can do that in cpu-parallel (it doesn't now)? That might be kinda cool
* sub is-prime($n where $n > 2) { $n % none(2..sqrt($n)) == 0 } # Logical O(1) prime test if only you had that quantum-coprocessor? That... would be kinda cool
* ... you might notice a pattern to the motivation for this feature :)
no idea what all(@ar1) < any(@ar2) would be
> my @a = <1 2 3 4>;
[1 2 3 4]
> my @b = <2 3>;
[2 3]
> say so all(@a) < any(@b);
False
> say so all(@b) < any(@a);
TrueIt seems that it just expands the lists using the operator. The output from junctions is quite nice:
> my @a = <1 2 3 4>;
> my @b = <2 3>;
> say all(@a) < any(@b);
all(any(True, True), any(False, True), any(False, False), any(False, False))
> say so all(@a) < any(@b);
FalseThing is, operators in perl6 are basically multimethods under the hood, as is pretty much everything else - so it's a much saner, more predictable thing than, say, the bag of razorblades that is perl5 overloading (which I've used to good effect, but, still, razorblades ;).