untangle antipairs vs invert

rakudo · Feb 28, 2015 · 06f9b89 · 06f9b89
1 parent 3eb4463
commit 06f9b89
Show file tree

Hide file tree

Showing 12 changed files with 56 additions and 32 deletions.
diff --git a/src/core/Any.pm b/src/core/Any.pm
@@ -77,13 +77,13 @@ my class Any { # declared in BOOTSTRAP
     multi method pairs(Any:U:) { ().list }
     multi method pairs(Any:D:) { self.list.pairs }
 
-    proto method exchange(|) { * }
-    multi method exchange(Any:U:) { ().list }
-    multi method exchange(Any:D:) { self.list.pairs }
+    proto method antipairs(|) { * }
+    multi method antipairs(Any:U:) { ().list }
+    multi method antipairs(Any:D:) { self.list.pairs }
 
     proto method invert(|) { * }
     multi method invert(Any:U:) { ().list }
-    multi method invert(Any:D:) { self.hash.invert }
+    multi method invert(Any:D:) { self.list.invert }
 
     method squish(|c) { self.list.squish(|c) }
     method rotor(|c) { self.list.rotor(|c) }

diff --git a/src/core/Bag.pm b/src/core/Bag.pm
@@ -19,7 +19,7 @@ my class Bag does Baggy {
     multi method pairs(Bag:D:) {    # must copy, else we would change the Bag
         %!elems.values.map: { Enum.new(:key(.key),:value(.value)) };
     }
-    multi method exchange(Bag:D:) { # must copy, else we would change the Bag
+    multi method antipairs(Bag:D:) { # must copy, else we would change the Bag
         %!elems.values.map: { Enum.new(:key(.value),:value(.key)) };
     }
 

diff --git a/src/core/Baggy.pm b/src/core/Baggy.pm
@@ -8,8 +8,8 @@ my role Baggy does QuantHash {
     multi method kv(Baggy:D:)       { %!elems.values.map( {.key, .value} ) }
     multi method values(Baggy:D:)   { %!elems.values.map( {.value} ) }
     multi method pairs(Baggy:D:)    { %!elems.values.map: { (.key => .value) } }
-    multi method exchange(Baggy:D:) { %!elems.values.map: { (.value => .key) } }
-    multi method invert(Baggy:D:)   { %!elems.values.map: { (.value => .key) } }
+    multi method antipairs(Baggy:D:) { %!elems.values.map: { (.value => .key) } }
+    multi method invert(Baggy:D:)   { %!elems.values.map: { (.value => .key) } } # NB value can't be listy
 
     method kxxv { %!elems.values.map( {.key xx .value} ) }
     method elems(--> Int) { %!elems.elems }

diff --git a/src/core/Capture.pm b/src/core/Capture.pm
@@ -133,8 +133,8 @@ my class Capture { # declared in BOOTSTRAP
     multi method pairs(Capture:D:) {
         (self.list.pairs, self.hash.pairs).flat;
     }
-    multi method exchange(Capture:D:) {
-        (self.list.exchange, self.hash.exchange).flat;
+    multi method antipairs(Capture:D:) {
+        (self.list.antipairs, self.hash.antipairs).flat;
     }
 }
 

diff --git a/src/core/Enum.pm b/src/core/Enum.pm
@@ -16,13 +16,14 @@ my class Enum does Associative {
 
     method key(Enum:D:)   { $!key }
     method value(Enum:D:) { $!value }
+    method antipair(Enum:D:) { self.new(key => $!value, value => $!key) }
 
-    multi method keys(Enum:D:)     { ($!key,).list }
-    multi method kv(Enum:D:)       { $!key, $!value }
-    multi method values(Enum:D:)   { ($!value,).list }
-    multi method pairs(Enum:D:)    { (self,).list }
-    multi method exchange(Enum:D:) { self.new(key => $!value, value => $!key) }
-    multi method invert(Enum:D:)   { self.new(key => $!value, value => $!key) }
+    multi method keys(Enum:D:)      { ($!key,).list }
+    multi method kv(Enum:D:)        { $!key, $!value }
+    multi method values(Enum:D:)    { ($!value,).list }
+    multi method pairs(Enum:D:)     { (self,).list }
+    multi method antipairs(Enum:D:) { self.new(key => $!value, value => $!key) }
+    multi method invert(Enum:D:)    { $!value »=>» $!key }
 
     multi method Str(Enum:D:) { $.key ~ "\t" ~ $.value }
 

diff --git a/src/core/EnumMap.pm b/src/core/EnumMap.pm
@@ -68,8 +68,8 @@ my class EnumMap does Associative { # declared in BOOTSTRAP
     multi method pairs(EnumMap:D:) {
         (nqp::defined($!storage) ?? HashIter.pairs(self)    !! ()).list;
     }
-    multi method exchange(EnumMap:D:) {
-        (nqp::defined($!storage) ?? HashIter.exchange(self) !! ()).list;
+    multi method antipairs(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.antipairs(self) !! ()).list;
     }
     multi method invert(EnumMap:D:) {
         (nqp::defined($!storage) ?? HashIter.invert(self)   !! ()).list;

diff --git a/src/core/Hash.pm b/src/core/Hash.pm
@@ -374,9 +374,9 @@ my class Hash { # declared in BOOTSTRAP
             return unless self.DEFINITE && nqp::defined($!keys);
             HashIter.pairs(self,$!keys).list
         }
-        method exchange(EnumMap:) {
+        method antipairs(EnumMap:) {
             return unless self.DEFINITE && nqp::defined($!keys);
-            HashIter.exchange(self,$!keys).list
+            HashIter.antipairs(self,$!keys).list
         }
         method invert(EnumMap:) {
             return unless self.DEFINITE && nqp::defined($!keys);

diff --git a/src/core/HashIter.pm b/src/core/HashIter.pm
@@ -4,21 +4,22 @@ my class HashIter is Iterator {
     has Mu $!keystore;         # key store, if it's a typed hash
     has int $!mode;            # pair = 0, kv = 1, k = 2, v = 3, invert = 4
 
-    method new($hash, :$keystore, :$pairs, :$kv, :$k, :$v, :$invert) {
+    method new($hash, :$keystore, :$pairs, :$kv, :$k, :$v, :$anti, :$invert) {
         nqp::create(self).BUILD($hash, $keystore,
             $pairs  ?? 0 !!
             $kv     ?? 1 !!
             $k      ?? 2 !!
             $v      ?? 3 !!
-            $invert ?? 4 !!
+            $anti   ?? 4 !!
+            $invert ?? 5 !!
                        0);
     }
-    method pairs($h,$keystore?)    { nqp::create(self).BUILD($h,$keystore,0) }
-    method kv($h,$keystore?)       { nqp::create(self).BUILD($h,$keystore,1) }
-    method keys($h,$keystore?)     { nqp::create(self).BUILD($h,$keystore,2) }
-    method values($h,$keystore?)   { nqp::create(self).BUILD($h,$keystore,3) }
-    method invert($h,$keystore?)   { nqp::create(self).BUILD($h,$keystore,4) }
-    method exchange($h,$keystore?) { nqp::create(self).BUILD($h,$keystore,4) }
+    method pairs($h,$keystore?)     { nqp::create(self).BUILD($h,$keystore,0) }
+    method kv($h,$keystore?)        { nqp::create(self).BUILD($h,$keystore,1) }
+    method keys($h,$keystore?)      { nqp::create(self).BUILD($h,$keystore,2) }
+    method values($h,$keystore?)    { nqp::create(self).BUILD($h,$keystore,3) }
+    method antipairs($h,$keystore?) { nqp::create(self).BUILD($h,$keystore,4) }
+    method invert($h,$keystore?)    { nqp::create(self).BUILD($h,$keystore,5) }
 
     submethod BUILD($hash, $keystore, Int $mode) {
         $!hashiter :=
@@ -90,7 +91,7 @@ my class HashIter is Iterator {
                     nqp::push($rpa, nqp::hllize(nqp::iterval($pairish)).item);
                 }
             }
-            elsif $mode == 4 {  # :invert & :exchange
+            elsif $mode == 4 {  # :anti
                 if nqp::defined($!keystore) {
                     while $it {
                         $pairish := nqp::shift($it);
@@ -108,6 +109,28 @@ my class HashIter is Iterator {
                     }
                 }
             }
+            elsif $mode == 5 {  # :invert
+                if nqp::defined($!keystore) {
+                    while $it {
+                        $pairish := nqp::shift($it);
+                        my $k := nqp::atkey($!keystore, nqp::iterkey_s($pairish));
+                        nqp::push($rpa, Pair.new(
+                            :value($k),
+                            :key($_)))
+                                for nqp::hllize(nqp::iterval($pairish)).list;
+                    }
+                }
+                else {
+                    while $it {
+                        $pairish := nqp::shift($it);
+                        my $k := nqp::p6box_s(nqp::iterkey_s($pairish));
+                        nqp::push($rpa, Pair.new(
+                            :value($k),
+                            :key($_)))
+                                for nqp::hllize(nqp::iterval($pairish)).list;
+                    }
+                }
+            }
             else {
                 die "Unknown hash iteration mode: $mode";
             }

diff --git a/src/core/List.pm b/src/core/List.pm
@@ -594,7 +594,7 @@ my class List does Positional { # declared in BOOTSTRAP
     multi method pairs(List:D:) {
         self.values.map: { (state $)++ => $_ }
     }
-    multi method exchange(List:D:) {
+    multi method antipairs(List:D:) {
         self.values.map: { $_ => (state $)++ }
     }
 

diff --git a/src/core/Mix.pm b/src/core/Mix.pm
@@ -10,7 +10,7 @@ my class Mix does Mixy {
     multi method pairs(Mix:D:) {    # copy values else we can change the Mix
         %!elems.values.map: { Enum.new(:key(.key),:value(.value)) };
     }
-    multi method exchange(Mix:D:) { # copy values else we can change the Mix
+    multi method antipairs(Mix:D:) { # copy values else we can change the Mix
         %!elems.values.map: { Enum.new(:key(.value),:value(.key)) };
     }
 

diff --git a/src/core/Set.pm b/src/core/Set.pm
@@ -29,7 +29,7 @@ my class Set does Setty {
     multi method pairs(Set:D:) {    # must copy else we can change the Set
         %!elems.values.map: { Enum.new(:key($_),:value(True)) };
     }
-    multi method exchange(Set:D:) { # must copy else we can change the Set
+    multi method antipairs(Set:D:) { # must copy else we can change the Set
         %!elems.values.map: { Enum.new(:key(True),:value($_)) };
     }
 

diff --git a/src/core/Setty.pm b/src/core/Setty.pm
@@ -65,7 +65,7 @@ my role Setty does QuantHash {
 
     method list() { %!elems.values }
     multi method pairs(Setty:D:)    { %!elems.values.map: { $_ => True } }
-    multi method exchange(Setty:D:) { %!elems.values.map: { True => $_ } }
+    multi method antipairs(Setty:D:) { %!elems.values.map: { True => $_ } }
     method grab($count = 1) {
         (%!elems{ %!elems.keys.pick($count) }:delete).list;
     }