Make .keys/kv/values/pairs/invert multi methods

This will also make all of these methods return an empty list on a type object. Should we decide that these methods should return Nil on type objects, this can now be easily achieved by changing the U: candidates in Any.pm
rakudo · Jan 12, 2015 · b55db85 · b55db85
1 parent 49a0bf5
commit b55db85
Show file tree

Hide file tree

Showing 11 changed files with 66 additions and 55 deletions.
diff --git a/src/core/Any.pm b/src/core/Any.pm
@@ -63,14 +63,30 @@ my class Any { # declared in BOOTSTRAP
     multi method end(Any:U:) { -1 }
     multi method end(Any:D:) { self.list.end }
 
+    proto method keys(|) { * }
+    multi method keys(Any:U:) { ().list }
+    multi method keys(Any:D:) { self.list.keys }
+
+    proto method kv(|) { * }
+    multi method kv(Any:U:) { ().list }
+    multi method kv(Any:D:) { self.list.kv }
+
+    proto method values(|) { * }
+    multi method values(Any:U:) { ().list }
+    multi method values(Any:D:) { self.list }
+
+    proto method pairs(|) { * }
+    multi method pairs(Any:U:) { ().list }
+    multi method pairs(Any:D:)  { self.list.pairs }
+
+    proto method invert(|) { * }
+    multi method invert(Any:U:) { ().list }
+    multi method invert(Any:D:) { self.list.invert }
+
     method squish(|c) { self.list.squish(|c) }
     method rotor(|c) { self.list.rotor(|c) }
     method reverse() { self.list.reverse }
     method sort($by = &infix:<cmp>) { self.list.sort($by) }
-    method values() { self.list }
-    method keys()   { self.list.keys }
-    method kv()     { self.list.kv }
-    method pairs()  { self.list.pairs }
     method reduce(&with) { self.list.reduce(&with) }
     method combinations(|c) { self.list.combinations(|c) }
     method permutations(|c) { self.list.permutations(|c) }

diff --git a/src/core/Bag.pm b/src/core/Bag.pm
@@ -17,7 +17,7 @@ my class Bag does Baggy {
           ?? %!elems{$key}.value
           !! 0;
     }
-    method pairs() {
+    multi method pairs() {   # need to copy, otherwise we would change the Bag
         @!pairs ||= %!elems.values.map: { Enum.new(:key(.key),:value(.value)) };
     }
 

diff --git a/src/core/Baggy.pm b/src/core/Baggy.pm
@@ -3,9 +3,13 @@ my role Baggy does QuantHash {
 
     method BUILD (:%!elems) { self }
     method default(--> Int) { 0 }
-    method keys { %!elems.values.map( {.key} ) }
-    method values { %!elems.values.map( {.value} ) }
-    method kv { %!elems.values.map( {.key, .value} ) }
+
+    multi method keys(Baggy:D:)   { %!elems.values.map( {.key} ) }
+    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 invert(Baggy:D:) { %!elems.values.map: { ( .value => .key ) } }
+
     method kxxv { %!elems.values.map( {.key xx .value} ) }
     method elems(--> Int) { %!elems.elems }
     method total(--> Int) { [+] self.values }
@@ -15,7 +19,6 @@ my role Baggy does QuantHash {
     method Bool { %!elems.Bool }
 
     method hash(--> Hash) { %!elems.values.hash }
-    method invert(--> List) { %!elems.values.map: { ( .value => .key ) } }
 
     method new(*@args --> Baggy) {
         my %e;
@@ -70,7 +73,6 @@ my role Baggy does QuantHash {
     }
 
     method list() { self.pairs }
-    method pairs() { %!elems.values.map: { (.key => .value) } }
 
     proto method grabpairs (|) { * }
     multi method grabpairs(Baggy:D:) {

diff --git a/src/core/Capture.pm b/src/core/Capture.pm
@@ -121,17 +121,17 @@ my class Capture { # declared in BOOTSTRAP
     method FLATTENABLE_LIST() { $!list ?? $!list !! nqp::list() }
     method FLATTENABLE_HASH() { $!hash ?? $!hash !! nqp::hash() }
 
-    method pairs(Capture:D:) {
-        (self.list.pairs, self.hash.pairs).flat
+    multi method keys(Capture:D:) {
+        (self.list.keys, self.hash.keys).flat;
     }
-    method values(Capture:D:) {
-        (self.list.values, self.hash.values).flat
+    multi method kv(Capture:D:) {
+        (self.list.kv, self.hash.kv).flat;
     }
-    method keys(Capture:D:) {
-        (self.list.keys, self.hash.keys).flat
+    multi method values(Capture:D:) {
+        (self.list.values, self.hash.values).flat;
     }
-    method kv(Capture:D:) {
-        (self.list.kv, self.hash.kv).flat
+    multi method pairs(Capture:D:) {
+        (self.list.pairs, self.hash.pairs).flat;
     }
 }
 

diff --git a/src/core/Enum.pm b/src/core/Enum.pm
@@ -14,17 +14,14 @@ my class Enum does Associative {
         $topic."$method"() === $.value;
     }
 
-    method invert() {
-        self.new(key => $.value, value => $.key);
-    }
-
     method key(Enum:D:)   { $!key }
-    method kv(Enum:D:)    { $!key, $!value }
     method value(Enum:D:) { $!value }
 
-    method keys(Enum:D:)  { ($!key,).list }
-    method values(Enum:D:){ ($!value,).list }
-    method pairs(Enum:D:) { (self,).list }
+    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 invert(Enum:D:) { self.new(key => $!value, value => $!key) }
 
     multi method Str(Enum:D:) { $.key ~ "\t" ~ $.value }
 

diff --git a/src/core/EnumMap.pm b/src/core/EnumMap.pm
@@ -49,25 +49,20 @@ my class EnumMap does Associative { # declared in BOOTSTRAP
     method iterator(EnumMap:) { self.pairs.iterator }
     method list(EnumMap:) { self.pairs }
 
-    method keys(EnumMap:) {
-        return unless self.DEFINITE && nqp::defined($!storage);
-        HashIter.new(self, :k).list
+    multi method keys(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.new(self, :k) !! ()).list;
     }
-    method kv(EnumMap:) {
-        return unless self.DEFINITE && nqp::defined($!storage);
-        HashIter.new(self, :kv).list
+    multi method kv(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.new(self, :kv) !! ()).list;
     }
-    method values(EnumMap:) {
-        return unless self.DEFINITE && nqp::defined($!storage);
-        HashIter.new(self, :v).list
+    multi method values(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.new(self, :v) !! ()).list;
     }
-    method pairs(EnumMap:) {
-        return unless self.DEFINITE && nqp::defined($!storage);
-        HashIter.new(self, :pairs).list
+    multi method pairs(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.new(self, :pairs) !! ()).list;
     }
-    method invert(EnumMap:) {
-        return unless self.DEFINITE && nqp::defined($!storage);
-        HashIter.new(self, :invert).list
+    multi method invert(EnumMap:D:) {
+        (nqp::defined($!storage) ?? HashIter.new(self, :invert) !! ()).list;
     }
 
     method at_key($key) is rw {

diff --git a/src/core/Enumeration.pm b/src/core/Enumeration.pm
@@ -13,7 +13,7 @@ my role Enumeration {
         $!key
     }
 
-    method kv(::?CLASS:D:) { ($!key, $!value) }
+    multi method kv(::?CLASS:D:) { ($!key, $!value) }
 
     method pair(::?CLASS:D:) { $!key => $!value }
 

diff --git a/src/core/List.pm b/src/core/List.pm
@@ -587,21 +587,20 @@ my class List does Positional { # declared in BOOTSTRAP
         self.DUMP-OBJECT-ATTRS($attrs, :$indent-step, :%ctx, :$flags);
     }
 
-    method keys(List:) {
+    multi method keys(List:D:) {
         self.values.map: { (state $)++ }
     }
-    method values(List:) {
-        return unless self.DEFINITE;
+    multi method kv(List:D:) {
+        self.values.map: { ((state $)++, $_) }
+    }
+    multi method values(List:D:) {
         my Mu $rpa := nqp::clone(nqp::p6listitems(self));
         nqp::push($rpa, $!nextiter) if $!nextiter.defined;
         nqp::p6list($rpa, List, self.flattens);
     }
-    method pairs(List:) {
+    multi method pairs(List:D:) {
         self.values.map: {; (state $)++ => $_ }
     }
-    method kv(List:) {
-        self.values.map: { ((state $)++, $_) }
-    }
 
     method reduce(List: &with) {
         fail('can only reduce with arity 2')

diff --git a/src/core/Mix.pm b/src/core/Mix.pm
@@ -8,7 +8,7 @@ my class Mix does Mixy {
           ~ '|'
           ~ %!elems.keys.sort.map( { $_ ~ '(' ~ %!elems{$_}.value ~ ')' } );
     }
-    method pairs() {
+    multi method pairs(Mix:D:) { # copy values otherwise we can change the Mix
         @!pairs ||= %!elems.values.map: { Enum.new(:key(.key),:value(.value)) };
     }
 

diff --git a/src/core/Set.pm b/src/core/Set.pm
@@ -27,7 +27,7 @@ my class Set does Setty {
         X::Immutable.new( method => 'grabpairs', typename => self.^name ).throw;
     }
 
-    method pairs() {
+    multi method pairs(Set:D:) { # need to copy otherwise we can change the Set
         @!pairs ||= %!elems.values.map: { Enum.new(:key($_),:value(True)) };
     }
 

diff --git a/src/core/Setty.pm b/src/core/Setty.pm
@@ -3,9 +3,11 @@ my role Setty does QuantHash {
 
     method BUILD (:%!elems)  { self }
     method default(--> Bool) { False }
-    method keys { %!elems.values }
-    method values { True xx %!elems.elems }
-    method kv { %!elems.values X, True }
+
+    multi method keys(Setty:D:)   { %!elems.values }
+    multi method kv(Setty:D:)     { %!elems.values X, True }
+    multi method values(Setty:D:) { True xx %!elems.elems }
+
     method elems(--> Int) { %!elems.elems }
     method total(--> Int) { %!elems.elems }
     method minpairs(--> List) { self.pairs }
@@ -62,7 +64,7 @@ my role Setty does QuantHash {
     }
 
     method list() { %!elems.values }
-    method pairs() { %!elems.values.map: { $_ => True } }
+    multi method pairs(Setty:D:) { %!elems.values.map: { $_ => True } }
     method grab($count = 1) {
         (%!elems{ %!elems.keys.pick($count) }:delete).list;
     }