Add :view named parameter to KeySet.Set and KeyBag.Bag coercers

This is a test to see whether this makes sense or not: basically, whenever
we coerce a KeySet to a Set, or a KeyBag to a Bag, and the :view parameter
is specified, we create an object using the same underlying :elems hash.
This prevents wasteful copying e.g. inside the (&) and other operators.

src/core/Baggy.pm

@@ -214,8 +214,8 @@ my role Baggy does Associative {
 }
 
 only sub infix:<(.)>(**@p) {
-    my $set = Set.new: @p.map(*.Set.keys);
-    my @bags = @p.map(*.Bag);
+    my $set = Set.new: @p.map(*.Set(:view).keys);
+    my @bags = @p.map(*.Bag(:view));
     Bag.new-fp($set.map({ ; $_ => [*] @bags>>.{$_} }));
 }
 # U+228D MULTISET MULTIPLICATION
@@ -224,8 +224,8 @@ only sub infix:<<"\x228D">>(|p) {
 }
 
 only sub infix:<(+)>(**@p) {
-    my $set = Set.new: @p.map(*.Set.keys);
-    my @bags = @p.map(*.Bag);
+    my $set = Set.new: @p.map(*.Set(:view).keys);
+    my @bags = @p.map(*.Bag(:view));
     Bag.new-fp($set.map({ ; $_ => [+] @bags>>.{$_} }));
 }
 # U+228E MULTISET UNION

src/core/KeyBag.pm

@@ -1,5 +1,14 @@
 my class KeyBag does Baggy {
 
-    method Bag { Bag.new-fp(nqp::getattr(self, KeyBag, '%!elems').values) }
+    method Bag (:$view) {
+        if $view {
+            my $bag := nqp::create(Bag);
+            $bag.BUILD( :elems(nqp::getattr(self, KeyBag, '%!elems')) );
+            $bag;
+        }
+        else {
+            Bag.new-fp(nqp::getattr(self, KeyBag, '%!elems').values);
+        }
+    }           
     method KeyBag { self }
 }

src/core/KeySet.pm

@@ -1,5 +1,15 @@
 my class KeySet does Setty {
 
-    method Set { Set.new(self.keys) }
+    method Set (:$view) {
+        if $view {
+            my $set := nqp::create(Set);
+            $set.BUILD( :elems(nqp::getattr(self, KeySet, '%!elems')) );
+            $set;
+        }
+        else {
+            Set.new(self.keys);
+        }
+    }
+
     method KeySet { self }
 }

src/core/Setty.pm

@@ -148,7 +148,7 @@ only sub infix:<<"\x222A">>(|p) {
 only sub infix:<(&)>(**@p) {
     if @p.first(Baggy) {
         my $keybag = @p ?? @p.shift.KeyBag !! KeyBag.new;
-        for @p.map(*.Bag) -> $bag {
+        for @p.map(*.Bag(:view)) -> $bag {
             $bag{$_}
               ?? $keybag{$_} min= $bag{$_}
               !! $keybag.delete($_)
@@ -158,7 +158,7 @@ only sub infix:<(&)>(**@p) {
     }
     else {
         my $keyset = @p ?? @p.shift.KeySet !! KeySet.new;
-        for @p.map(*.Set) -> $set {
+        for @p.map(*.Set(:view)) -> $set {
             $set{$_} || $keyset.delete($_) for $keyset.keys;
         }
         Set.new($keyset.keys);
@@ -172,12 +172,12 @@ only sub infix:<<"\x2229">>(|p) {
 only sub infix:<(-)>(**@p) {
     return set() unless @p;
     if @p[0] ~~ Baggy {
-        my @bags = @p.map(*.Bag);
+        my @bags = @p.map(*.Bag(:view));
         my $base = @bags.shift;
         Bag.new-fp($base.keys.map({ ; $_ => $base{$_} - [+] @bags>>.{$_} }));
     }
     else {
-        my @sets = @p.map(*.Set);
+        my @sets = @p.map(*.Set(:view));
         my $base = @sets.shift;
         Set.new: $base.keys.grep(* !(elem) @sets.any );
     }