Documentation for routine antipairs assembled from the following types:

role Baggy

From Baggy

(Baggy) method antipairs

Defined as:

method antipairs(Baggy:D: --> Seq:D)

Returns all elements and their respective weights as a Seq of Pairs, where the element itself is the value and the weight of that element is the key, i.e. the opposite of method pairs.

my $breakfast = bag <bacon eggs bacon>;
my $seq = $breakfast.antipairs;
say $seq.sort;                                    # OUTPUT: «(1 => eggs 2 => bacon)␤»

role Setty

From Setty

(Setty) method antipairs

Defined as:

multi method antipairs(Setty:D: --> Seq:D)

Returns all elements in the set and True as a Seq of Pairs, where the element itself is the value, i.e. the opposite of method pairs.

my $s = Set.new(1, 2, 3, 1);
say $s.antipairs.sort;                            # OUTPUT: «(True => 1 True => 2 True => 3)␤»

class Any

From Any

(Any) method antipairs

Defined as:

multi method antipairs(Any:U:)
multi method antipairs(Any:D:)

Returns an empty List if the invocant is a type object

Range.antipairs.say; # OUTPUT: «()␤»

If it's a value object, it returns the inverted list of pairs after converting it to a list of pairs; the values will become keys and the other way round.

%(s => 1, t=> 2, u => 3).antipairs.say ;# OUTPUT: «(2 => t 1 => s 3 => u)␤»

class Map

From Map

(Map) method antipairs

Defined as:

method antipairs(Map:D: --> Seq:D)

Returns all keys and their respective values as a Seq of Pairs where the keys and values have been exchanged, i.e. the opposite of method pairs. Unlike the invert method, there is no attempt to expand list values into multiple pairs.

my $m = Map.new('a' => (2, 3), 'b' => 17);
say $m.antipairs;                                  # OUTPUT: «((2 3) => a 17 => b)␤»

class Pair

From Pair

(Pair) method antipairs

Defined as:

multi method antipairs(Pair:D:)

Returns a List containing the antipair of the invocant.

my $p = (6 => 'Perl').antipairs;
say $p.^name;                                     # OUTPUT: «List␤» 
say $p.first;                                     # OUTPUT: «Perl => 6␤» 
say $p.first.^name;                               # OUTPUT: «Pair␤»

class Capture

From Capture

(Capture) method antipairs

Defined as:

multi method antipairs(Capture:D: --> Seq:D)

Returns all arguments, the positional followed by the named, as a Seq of pairs where the keys and values have been swapped, i.e. the value becomes the key and the key becomes the value. This behavior is the opposite of the pairs method.

my $capture = \(2, 3, apples => (red => 2));
say $capture.antipairs;                           # OUTPUT: «(2 => 0 3 => 1 (red => 2) => apples)␤»

class List

From List

(List) routine antipairs

Defined as:

method antipairs(List:D: --> Seq:D)

Returns a Seq of pairs, with the values as keys and the indexes as values, i.e. the direct opposite to pairs.

say <a b c>.antipairs;  # OUTPUT: «(a => 0 b => 1 c => 2)␤»