Handle more paranoid infix:<eqv> of 463e758

lizmat · lizmat · commit ae3ad504c648 · 2016-04-21T18:28:25.000+01:00
diff --git a/S32-list/categorize.t b/S32-list/categorize.t
@@ -7,10 +7,10 @@ plan 28;
 
 { # basic categorize with all possible mappers
     my @list      = 29, 7, 12, 9, 18, 23, 3, 7;
-    my %expected1 =
-      ('0'=>[7,9,3,7],         '10'=>[12,18],       '20'=>[29,23]);
-    my %expected2 =
-      ('0'=>[7,9,3,7,7,9,3,7], '10'=>[12,18,12,18], '20'=>[29,23,29,23]);
+    my %expected1{Any} =
+      (0=>[7,9,3,7],         10=>[12,18],       20=>[29,23]);
+    my %expected2{Any} =
+      (0=>[7,9,3,7,7,9,3,7], 10=>[12,18,12,18], 20=>[29,23,29,23]);
     my sub subber ($a) { $a - ($a % 10) };
     my $blocker = { $_ - ($_ % 10) };
     my $hasher  = { 3=>0, 7=>0, 9=>0, 12=>10, 18=>10, 23=>20, 29=>20 };
@@ -22,14 +22,14 @@ plan 28;
         is-deeply @list.categorize( $mapper ), %expected1,
           "method call on list with {$mapper.^name}";
 
-        categorize( $mapper, @list, :into(my %h) );
+        categorize( $mapper, @list, :into(my %h{Any}) );
         is-deeply %h, %expected1,
           "basic categorize as sub with {$mapper.^name} and new into";
         categorize( $mapper, @list, :into(%h) );
         is-deeply %h, %expected2,
           "basic categorize as sub with {$mapper.^name} and existing into";
 
-        @list.categorize( $mapper, :into(my %i) );
+        @list.categorize( $mapper, :into(my %i{Any}) );
         is-deeply %i, %expected1,
           "basic categorize from list with {$mapper.^name} and new into";
         @list.categorize( $mapper, :into(%i) );
@@ -91,12 +91,13 @@ plan 28;
 #?niecza todo 'feature'
 {
     is-deeply( categorize( { map { [$_+0, $_+10] }, .comb }, 100,104,112,119 ),
-      :{1 => :{ 11 => [100, 104, 112, 112, 119, 119] },
-        0 => :{ 10 => [100, 100, 104] },
-        4 => :{ 14 => [104] },
-        2 => :{ 12 => [112] },
-        9 => :{ 19 => [119] },
-      }, 'multi-level categorize' );
+      (my %{Any} =
+        1 => ( my %{Any} = 11 => [100, 104, 112, 112, 119, 119] ),
+        0 => ( my %{Any} = 10 => [100, 100, 104] ),
+        4 => ( my %{Any} = 14 => [104] ),
+        2 => ( my %{Any} = 12 => [112] ),
+        9 => ( my %{Any} = 19 => [119] ),
+      ), 'multi-level categorize' );
 }
 
 # vim: ft=perl6
diff --git a/S32-list/classify.t b/S32-list/classify.t
@@ -7,31 +7,31 @@ plan 40;
 
 {
     my @list = 1, 2, 3, 4;
-    my $classified1 = { even => [2,4],     odd => [1,3]     };
-    my $classified2 = { even => [2,4,2,4], odd => [1,3,1,3] };
+    my %classified1{Any} = even => [2,4],     odd => [1,3];
+    my %classified2{Any} = even => [2,4,2,4], odd => [1,3,1,3];
     my sub subber ($a) { $a % 2 ?? 'odd' !! 'even' };
     my $blocker = { $_ % 2 ?? 'odd' !! 'even' };
     my $hasher  = { 1 => 'odd', 2 => 'even', 3 => 'odd', 4 => 'even' };
     my $arrayer = <huh odd even odd even>.list;
 
     for &subber, $blocker, $hasher, $arrayer -> $classifier {
-        is-deeply @list.classify( $classifier ), $classified1,
+        is-deeply @list.classify( $classifier ), %classified1,
           "basic classify from list with {$classifier.^name}";
-        is-deeply classify( $classifier, @list ), $classified1,
+        is-deeply classify( $classifier, @list ), %classified1,
           "basic classify as subroutine with {$classifier.^name}";
 
-        classify( $classifier, @list, :into(my %h) );
-        is-deeply %h, $classified1,
+        classify( $classifier, @list, :into(my %h{Any}) );
+        is-deeply %h, %classified1,
           "basic classify as sub with {$classifier.^name} and new into";
         classify( $classifier, @list, :into(%h) );
-        is-deeply %h, $classified2,
+        is-deeply %h, %classified2,
           "basic classify as sub with {$classifier.^name} and existing into";
 
-        @list.classify( $classifier, :into(my %i) );
-        is-deeply %i, $classified1,
+        @list.classify( $classifier, :into(my %i{Any}) );
+        is-deeply %i, %classified1,
           "basic classify from list with {$classifier.^name} and new into";
         @list.classify( $classifier, :into(%i) );
-        is-deeply %i, $classified2,
+        is-deeply %i, %classified2,
           "basic classify from list with {$classifier.^name} and existing into";
     }
     
@@ -54,57 +54,59 @@ plan 40;
 } #3
 
 {
-    my $result = { 5 => [1], 10 => [2], 15 => [3], 20 => [4] };
-    is-deeply classify( { $_ * 5 }, 1, 2, 3, 4 ), $result,
+    my %result{Any} = 5 => [1], 10 => [2], 15 => [3], 20 => [4];
+    is-deeply classify( { $_ * 5 }, 1, 2, 3, 4 ), %result,
       'can classify by numbers';
-    classify( { $_ * 5 }, 1, 2, 3, 4, :into(my %by_five) );
-    is-deeply %by_five, $result,
+    classify( { $_ * 5 }, 1, 2, 3, 4, :into(my %by_five{Any}) );
+    is-deeply %by_five, %result,
       'can classify by numbers into an existing empty hash';
     classify( { $_ * 5 }, 1, 2, 3, 4, :into(%by_five) );
-    $_[1] = $_[0] for $result.values;
-    is-deeply %by_five, $result,
+    $_[1] = $_[0] for %result.values;
+    is-deeply %by_five, %result,
       'can classify by numbers into an existing filled hash';
     classify( { $_ * 5 }, 1, 2, 3, 4, :into(%by_five), :as(* * 2) );
-    $_[2] = 2 * $_[1] for $result.values;
-    is-deeply %by_five, $result,
+    $_[2] = 2 * $_[1] for %result.values;
+    is-deeply %by_five, %result,
       'can classify by numbers into an existing filled hash with an :as';
 } #4
 
 # .classify should work on non-arrays
 {
-    is-deeply 42.classify(  {$_} ), { 42 => [42] }, "classify single num";
-    is-deeply "A".classify( {$_} ), { A => ["A"] }, "classify single string";
+    is-deeply 42.classify(  {$_} ), (my %{Any} = 42 => [42]), "classify single num";
+    is-deeply "A".classify( {$_} ), (my %{Any} = A => ["A"]), "classify single string";
 } #2
 
 #?niecza todo 'feature'
 {
     is-deeply( classify( {.comb}, flat 100 .. 119, 104, 119 ),
-      ("1" => {
-        "0" => {
-          "0" => [100],
-          "1" => [101],
-          "2" => [102],
-          "3" => [103],
-          "4" => [104,104],
-          "5" => [105],
-          "6" => [106],
-          "7" => [107],
-          "8" => [108],
-          "9" => [109],
-        },
-        "1" => {
-          "0" => [110],
-          "1" => [111],
-          "2" => [112],
-          "3" => [113],
-          "4" => [114],
-          "5" => [115],
-          "6" => [116],
-          "7" => [117],
-          "8" => [118],
-          "9" => [119,119],
-        }
-      }).hash, 'multi-level classify' );
+      (my %{Any} =
+        "1" => (my %{Any} =
+          "0" => (my %{Any} =
+            "0" => [100],
+            "1" => [101],
+            "2" => [102],
+            "3" => [103],
+            "4" => [104,104],
+            "5" => [105],
+            "6" => [106],
+            "7" => [107],
+            "8" => [108],
+            "9" => [109],
+          ),
+          "1" => (my %{Any} =
+            "0" => [110],
+            "1" => [111],
+            "2" => [112],
+            "3" => [113],
+            "4" => [114],
+            "5" => [115],
+            "6" => [116],
+            "7" => [117],
+            "8" => [118],
+            "9" => [119,119],
+          )
+        )
+      ), 'multi-level classify' );
 }
 
 is classify( { "foo" }, () ).elems, 0, 'classify an empty list';
@@ -113,7 +115,7 @@ is classify( { "foo" }, () ).elems, 0, 'classify an empty list';
 {
     is-deeply
         <a b c>.classify({ ~($ ~= $_); }),
-        {'a' => ['a'], 'ab' => ['b'], 'abc' => ['c']},
+        (my %{Any} = 'a' => ['a'], 'ab' => ['b'], 'abc' => ['c']),
         '&test only run once for each item';
 }
 
