Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
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
  • Loading branch information
lizmat committed Jan 12, 2015
1 parent 49a0bf5 commit b55db85
Show file tree
Hide file tree
Showing 11 changed files with 66 additions and 55 deletions.
24 changes: 20 additions & 4 deletions src/core/Any.pm
Expand Up @@ -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) }
Expand Down
2 changes: 1 addition & 1 deletion src/core/Bag.pm
Expand Up @@ -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)) };
}

Expand Down
12 changes: 7 additions & 5 deletions src/core/Baggy.pm
Expand Up @@ -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 }
Expand All @@ -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;
Expand Down Expand Up @@ -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:) {
Expand Down
16 changes: 8 additions & 8 deletions src/core/Capture.pm
Expand Up @@ -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;
}
}

Expand Down
13 changes: 5 additions & 8 deletions src/core/Enum.pm
Expand Up @@ -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 }

Expand Down
25 changes: 10 additions & 15 deletions src/core/EnumMap.pm
Expand Up @@ -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 {
Expand Down
2 changes: 1 addition & 1 deletion src/core/Enumeration.pm
Expand Up @@ -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 }

Expand Down
13 changes: 6 additions & 7 deletions src/core/List.pm
Expand Up @@ -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')
Expand Down
2 changes: 1 addition & 1 deletion src/core/Mix.pm
Expand Up @@ -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)) };
}

Expand Down
2 changes: 1 addition & 1 deletion src/core/Set.pm
Expand Up @@ -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)) };
}

Expand Down
10 changes: 6 additions & 4 deletions src/core/Setty.pm
Expand Up @@ -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 }
Expand Down Expand Up @@ -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;
}
Expand Down

0 comments on commit b55db85

Please sign in to comment.