Merge Enum into Pair

This should reduce the confusion around enum, Enum an Enumeration. Pair now implements shallow immutability like List. Pairs themselves are immutable, but containers used as values can be assigned to.
rakudo · Sep 19, 2015 · 2232157 · 2232157
1 parent a47d297
commit 2232157
Show file tree

Hide file tree

Showing 17 changed files with 104 additions and 112 deletions.
diff --git a/src/core/Any-iterable-methods.pm b/src/core/Any-iterable-methods.pm
@@ -683,7 +683,7 @@ augment class Any {
             !! self.list.iterator;
         gather loop {
             my $it := iter.pull-one;
-            if nqp::istype($it, Enum) {
+            if nqp::istype($it, Pair) {
                 take $it.key => $it.value
             }
             elsif nqp::istype($it, Map) and !nqp::iscont($it) {

diff --git a/src/core/Any.pm b/src/core/Any.pm
@@ -452,8 +452,8 @@ multi sub item(Mu $a) { $a }
 
 sub RWPAIR(\k, \v) {   # internal fast pair creation
     my \p := nqp::create(Pair);
-    nqp::bindattr(p, Enum, '$!key', k);
-    nqp::bindattr(p, Enum, '$!value', v);
+    nqp::bindattr(p, Pair, '$!key', k);
+    nqp::bindattr(p, Pair, '$!value', v);
     p
 }
 

diff --git a/src/core/Bag.pm b/src/core/Bag.pm
@@ -11,10 +11,10 @@ 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)) };
+        %!elems.values.map: { Pair.new(:key(.key),:value(.value)) };
     }
     multi method antipairs(Bag:D:) { # must copy, else we would change the Bag
-        %!elems.values.map: { Enum.new(:key(.value),:value(.key)) };
+        %!elems.values.map: { Pair.new(:key(.value),:value(.key)) };
     }
     multi method grab(Bag:D: $count?) {
         X::Immutable.new( method => 'grab', typename => self.^name ).throw;

diff --git a/src/core/BagHash.pm b/src/core/BagHash.pm
@@ -20,7 +20,7 @@ my class BagHash does Baggy {
           },
           STORE => -> $, $value is copy {
               if $value > 0 {
-                  (%!elems.AT-KEY(k.WHICH) //= ((k) => 0)).value = $value;
+                  (%!elems.AT-KEY(k.WHICH) //= ((k) => my $ = 0)).value = $value;
               }
               elsif $value == 0 {
                   %!elems.DELETE-KEY(k.WHICH);

diff --git a/src/core/Baggy.pm b/src/core/Baggy.pm
@@ -27,17 +27,17 @@ my role Baggy does QuantHash {
     method !new(@args) {
         my %e;
         # need explicit signature because of #119609
-        -> $_ { (%e{$_.WHICH} //= ($_ => 0)).value++ } for @args;
+        -> $_ { (%e{$_.WHICH} //= ($_ => my $ = 0)).value++ } for @args;
         self.bless(:elems(%e));
     }
     method new-from-pairs(*@pairs) {
         my %e;
         for @pairs {
             when Pair {
-                (%e.AT-KEY($_.key.WHICH) //= ($_.key => 0)).value += $_.value.Int;
+                (%e.AT-KEY($_.key.WHICH) //= ($_.key => my $ = 0)).value += $_.value.Int;
             }
             default {
-                (%e.AT-KEY($_.WHICH) //= ($_ => 0)).value++;
+                (%e.AT-KEY($_.WHICH) //= ($_ => my $ = 0)).value++;
             }
         }
         my @toolow;
@@ -134,7 +134,7 @@ my role Baggy does QuantHash {
     multi method pick(Baggy:D: $count) {
         ROLLPICKGRABN(self,
           nqp::istype($count,Whatever) || $count == Inf ?? self.total !! $count,
-          %!elems.values.map: { (.key => .value) }
+          %!elems.values.map: { (.key => my $ = .value) }
         );
     }
 

diff --git a/src/core/Enum.pm b/src/core/Enum.pm
diff --git a/src/core/Enumeration.pm b/src/core/Enumeration.pm
@@ -63,7 +63,7 @@ sub ANON_ENUM(*@args) {
     my Mu $prev = -1;
     my %res;
     for @args {
-        if .^isa(Enum) {
+        if .^isa(Pair) {
             %res{.key} = $prev = .value;
         }
         else {

diff --git a/src/core/Hash.pm b/src/core/Hash.pm
@@ -82,6 +82,7 @@ my class Hash { # declared in BOOTSTRAP
     method STORE_AT_KEY(\key, Mu $x) is rw {
         my $v := nqp::p6scalarfromdesc($!descriptor);
         nqp::findmethod(Map, 'STORE_AT_KEY')(self, key, $v = $x);
+        $v;
     }
 
     # introspection
@@ -129,7 +130,7 @@ my class Hash { # declared in BOOTSTRAP
             if $has_previous {
                 self!_push_construct($previous, $e);
                 $has_previous = 0;
-            } elsif $e.^isa(Enum) {
+            } elsif $e.^isa(Pair) {
                 self!_push_construct($e.key, $e.value);
             } else {
                 $previous = $e;

diff --git a/src/core/Map.pm b/src/core/Map.pm
@@ -169,7 +169,7 @@ my class Map does Iterable does Associative { # declared in BOOTSTRAP
             !! to_store.list.iterator;
         $!storage := nqp::hash();
         until (my Mu $x := iter.pull-one) =:= IterationEnd {
-            if nqp::istype($x,Enum) {
+            if nqp::istype($x,Pair) {
                 self.STORE_AT_KEY($x.key, $x.value)
             }
             elsif nqp::istype($x, Map) and !nqp::iscont($x) {

diff --git a/src/core/Mix.pm b/src/core/Mix.pm
@@ -8,10 +8,10 @@ my class Mix does Mixy {
           ~ %!elems.keys.sort.map( { $_ ~ '(' ~ %!elems{$_}.value ~ ')' } );
     }
     multi method pairs(Mix:D:) {    # copy values else we can change the Mix
-        %!elems.values.map: { Enum.new(:key(.key),:value(.value)) };
+        %!elems.values.map: { Pair.new(:key(.key),:value(.value)) };
     }
     multi method antipairs(Mix:D:) { # copy values else we can change the Mix
-        %!elems.values.map: { Enum.new(:key(.value),:value(.key)) };
+        %!elems.values.map: { Pair.new(:key(.value),:value(.key)) };
     }
 
     method total (--> Real) { $!total //= [+] self.values }

diff --git a/src/core/MixHash.pm b/src/core/MixHash.pm
@@ -20,7 +20,7 @@ my class MixHash does Mixy {
           },
           STORE => -> $, $value is copy {
               if $value != 0 {
-                  (%!elems.AT-KEY(k.WHICH) //= ((k) => 0)).value = $value;
+                  (%!elems.AT-KEY(k.WHICH) //= ((k) => my $ = 0)).value = $value;
               }
               else {
                   %!elems.DELETE-KEY(k.WHICH);

diff --git a/src/core/Mixy.pm b/src/core/Mixy.pm
@@ -6,10 +6,10 @@ my role Mixy does Baggy  {
         my %e;
         for @pairs {
             when Pair {
-                (%e.AT-KEY($_.key.WHICH) //= ($_.key => 0)).value += $_.value;
+                (%e.AT-KEY($_.key.WHICH) //= ($_.key => my $ = 0)).value += $_.value;
             }
             default {
-                (%e.AT-KEY($_.WHICH) //= ($_ => 0)).value++;
+                (%e.AT-KEY($_.WHICH) //= ($_ => my $ = 0)).value++;
             }
         }
         for %e -> $p {

diff --git a/src/core/Pair.pm b/src/core/Pair.pm
@@ -1,22 +1,96 @@
-my class Pair is Enum {
-    method value() is rw { nqp::getattr(self, Enum, '$!value') }
+my class Pair does Associative {
+    has $.key;
+    has $.value is rw;
+
+    multi method new($key, Mu \value) {
+        nqp::create(self).BUILD($key, value)
+    }
+    multi method new(:$key, Mu :$value) {
+        nqp::create(self).BUILD($key, $value)
+    }
+    method BUILD($!key, Mu \value) {
+        nqp::bindattr(self, Pair, '$!value', value);
+        self
+    }
 
     multi method ACCEPTS(Pair:D: %h) {
         $.value.ACCEPTS(%h{$.key});
     }
+
     multi method ACCEPTS(Pair:D: Mu $other) {
         $other."$.key"().Bool === $.value.Bool
     }
-    multi method AT-KEY(Pair:D: $key) { $key eq nqp::getattr(self, Enum, '$!key')
-      ?? nqp::getattr(self, Enum, '$!value')
-      !! Any;
+
+    method antipair(Pair:D:) { self.new(key => $!value, value => $!key) }
+
+    multi method keys(Pair:D:)      { ($!key,).list }
+    multi method kv(Pair:D:)        { $!key, $!value }
+    multi method values(Pair:D:)    { ($!value,).list }
+    multi method pairs(Pair:D:)     { (self,).list }
+    multi method antipairs(Pair:D:) { self.new(key => $!value, value => $!key) }
+    multi method invert(Pair:D:)    { $!value »=>» $!key }
+
+    multi method Str(Pair:D:) { $!key ~ "\t" ~ $!value }
+
+    multi method gist(Pair:D:) {
+        my $result;
+        if not %*gistseen<TOP> { my %*gistseen = :TOP ; return self.gist }
+        if %*gistseen{self.WHICH} { %*gistseen{self.WHICH} = 2; return "Pair_{self.WHERE}" }
+        %*gistseen{self.WHICH} = 1;
+        if nqp::istype($!key, Pair) {
+            $result = '(' ~ $!key.gist ~ ') => ' ~ $!value.gist;
+        } else {
+            $result = $!key.gist ~ ' => ' ~ $!value.gist;
+        }
+        $result = "(\\Pair_{self.WHERE} = $result)" if %*gistseen{self.WHICH}:delete == 2;
+        $result;
+    }
+
+    multi method perl(Pair:D: :$arglist) {
+        my $result;
+        if not %*perlseen<TOP> { my %*perlseen = :TOP ; return self.perl(:$arglist) }
+        if %*perlseen{self.WHICH} { %*perlseen{self.WHICH} = 2; return "Pair_{self.WHERE}" }
+        %*perlseen{self.WHICH} = 1;
+        if nqp::istype($!key, Pair) {
+            $result = '(' ~ $!key.perl ~ ') => ' ~ $!value.perl;
+        } elsif nqp::istype($!key, Str) and !$arglist and $!key ~~ /^ [<alpha>\w*] +% <[\-']> $/ {
+            if nqp::istype($!value,Bool) {
+                $result = ':' ~ '!' x !$!value ~ $!key;
+            } else {
+                $result = ':' ~ $!key ~ '(' ~ $!value.perl ~ ')';
+            }
+        } else {
+            $result = $!key.perl ~ ' => ' ~ $!value.perl;
+        }
+        $result = "(my \\Pair_{self.WHERE} = $result)" if %*perlseen{self.WHICH}:delete == 2;
+        $result;
+    }
+
+    method fmt($format = "%s\t%s") {
+        sprintf($format, $!key, $!value);
     }
+
+    multi method AT-KEY(Pair:D: $key)     { $key eq $!key ?? $!value !! Mu }
+    multi method EXISTS-KEY(Pair:D: $key) { $key eq $!key }
+
+    method FLATTENABLE_LIST() { nqp::list() }
+    method FLATTENABLE_HASH() { nqp::hash($!key, $!value) }
 }
 
-sub infix:«=>»($key, Mu $value) {
-    Pair.new(:$key, :$value)
+multi sub infix:<eqv>(Pair:D $a, Pair:D $b) {
+    $a.WHAT === $b.WHAT && $a.key eqv $b.key && $a.value eqv $b.value
 }
 
-sub pair($key,$value) { Pair.new(:$key,:$value) }
+multi sub infix:<cmp>(Pair:D \a, Pair:D \b) {
+    (a.key cmp b.key) || (a.value cmp b.value)
+}
+
+sub infix:«=>»($key, Mu \value) {
+    Pair.new($key, value)
+}
+
+sub pair($key, \value) {
+    Pair.new($key, value)
+}
 
 # vim: ft=perl6 expandtab sw=4
diff --git a/src/core/Set.pm b/src/core/Set.pm
@@ -16,10 +16,10 @@ 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)) };
+        %!elems.values.map: { Pair.new(:key($_),:value(True)) };
     }
     multi method antipairs(Set:D:) { # must copy else we can change the Set
-        %!elems.values.map: { Enum.new(:key(True),:value($_)) };
+        %!elems.values.map: { Pair.new(:key(True),:value($_)) };
     }
 
     method Set { self }

diff --git a/src/core/stubs.pm b/src/core/stubs.pm
@@ -6,7 +6,7 @@
 my class Exception { ... }
 my class X::AdHoc  { ... }
 my class FatRat    { ... }
-my class Enum      { ... }
+my class Pair      { ... }
 my class X::OutOfRange { ... }
 my class X::Dynamic::NotFound { ... }
 

diff --git a/tools/build/Makefile-JVM.in b/tools/build/Makefile-JVM.in
@@ -106,7 +106,6 @@ J_CORE_SOURCES = \
   src/core/Slip.pm \
   src/core/Array.pm \
   src/core/native_array.pm \
-  src/core/Enum.pm \
   src/core/Pair.pm \
   src/core/Map.pm \
   src/core/Hash.pm \

diff --git a/tools/build/moar_core_sources b/tools/build/moar_core_sources
@@ -55,7 +55,6 @@ src/core/array_slice.pm
 src/core/Slip.pm
 src/core/Array.pm
 src/core/native_array.pm
-src/core/Enum.pm
 src/core/Pair.pm
 src/core/Map.pm
 src/core/Hash.pm