Sidef/Types/Set/Bag.pm untested

filter: Statementstmt 0.0% 0 / 584 Branchbran 0.0% 0 / 86 Conditioncond 0.0% 0 / 74 MC/DCmcdc 0.0% 0 / 42 Subroutinesub 0.0% 0 / 77 Podpod 0.0% 0 / 65 totaltotal 0.0% 0 / 928 CC 42 SCAR 21.3
CC
42
Cov
0%
symmetric_difference
42.0
union
20.0
intersection
20.0
CRAP 8.4
1 package Sidef::Types::Set::Bag;
2  
3 use utf8;
4 use 5.016;
5  
6 use parent qw(
7 Sidef::Types::Set::Set
8 );
9  
10 use overload
11 q{bool} => sub { scalar(CORE::keys(%{$_[0]})) },
12 q{0+} => sub { scalar(CORE::keys(%{$_[0]})) },
13 q{@{}} => sub {
14 [map { ($_->{value}) x $_->{count} } CORE::values(%{$_[0]})]
15 },
16 q{""} => \&_dump;
17  
18 use Sidef::Types::Block::Block;
19 use Sidef::Types::Bool::Bool;
20 use Sidef::Types::Number::Number;
21  
22 my $serialize = sub {
23 my ($obj) = @_;
24 my $key = ref($obj) ? (UNIVERSAL::can($obj, 'dump') ? $obj->dump : $obj) : ($obj // 'nil');
25 "$key";
26 };
27  
28 sub new {
29 my (undef, @objects) = @_;
30  
31 my %bag;
32 foreach my $obj (@objects) {
33 ($bag{$serialize->($obj)} //= {value => $obj})->{count}++;
34 }
35  
36 bless \%bag;
37 }
38  
39 *call = \&new;
40  
41 sub get_value {
42 my %addr;
43  
44 my $sub = sub {
45 my ($obj) = @_;
46  
47 my $refaddr = Scalar::Util::refaddr($obj);
48  
49 CORE::exists($addr{$refaddr})
50 && return $addr{$refaddr};
51  
52 my @bag;
53 $addr{$refaddr} = \@bag;
54  
55 foreach my $hash (CORE::values(%$obj)) {
56  
57 my $v = $hash->{value};
58 my $c = $hash->{count};
59  
60 CORE::push(@bag, ((index(ref($v), 'Sidef::') == 0) ? $v->get_value : $v) x $c);
61 }
62  
63 $addr{$refaddr};
64 };
65  
66 no warnings 'redefine';
67 local *Sidef::Types::Set::Bag::get_value = $sub;
68 $sub->($_[0]);
69 }
70  
71 sub concat {
72 my ($A, $B) = @_;
73  
74 if (ref($A) eq ref($B)) {
75  
76 my %C = map { $_ => {%{$A->{$_}}} } CORE::keys(%$A);
77  
78 foreach my $key (CORE::keys(%$B)) {
79 ($C{$key} //= {value => $B->{$key}{value}})->{count} += $B->{$key}{count};
80 }
81  
82 return bless \%C, ref($A);
83 }
84  
85 my %C = %$A;
86 my $key = $serialize->($B);
87 ($C{$key} //= {value => $B})->{count}++;
88 bless \%C, ref($A);
89 }
90  
91 sub union {
92 my ($A, $B) = @_;
93  
94 if (ref($B) ne __PACKAGE__) {
95 $B = $B->to_bag;
96 }
97  
98 my %C = map { $_ => {%{$A->{$_}}} } CORE::keys(%$A);
99  
100 foreach my $key (CORE::keys(%$B)) {
101 if (CORE::exists($C{$key})) {
102  
103 my $elem = $C{$key};
104 my $c1 = $elem->{count};
105 my $c2 = $B->{$key}{count};
106  
107 if ($c2 > $c1) {
108 $elem->{count} = $c2;
109 }
110 }
111 else {
112 $C{$key} = {%{$B->{$key}}};
113 }
114 }
115  
116 bless \%C, ref($A);
117 }
118  
119 *or = \&union;
120  
121 sub intersection {
122 my ($A, $B) = @_;
123  
124 if (ref($B) ne __PACKAGE__) {
125 $B = $B->to_bag;
126 }
127  
128 my %C;
129  
130 foreach my $key (CORE::keys(%$A)) {
131 if (CORE::exists($B->{$key})) {
132  
133 my $h_A = $A->{$key};
134 my $h_B = $B->{$key};
135  
136 my $c_A = $h_A->{count};
137 my $c_B = $h_B->{count};
138  
139 $C{$key} = {
140 value => $h_A->{value},
141 count => ($c_A < $c_B ? $c_A : $c_B),
142 };
143 }
144 }
145  
146 bless \%C, ref($A);
147 }
148  
149 *and = \&intersection;
150  
151 sub difference {
152 my ($A, $B) = @_;
153  
154 if (ref($B) ne __PACKAGE__) {
155 $B = $B->to_bag;
156 }
157  
158 my %C;
159  
160 foreach my $key (CORE::keys(%$A)) {
161 if (CORE::exists($B->{$key})) {
162  
163 my $h_A = $A->{$key};
164 my $h_B = $B->{$key};
165  
166 my $c_A = $h_A->{count};
167 my $c_B = $h_B->{count};
168  
169 if ($c_A > $c_B) {
170 $C{$key} = {
171 value => $h_A->{value},
172 count => $c_A - $c_B,
173 };
174 }
175 }
176 else {
177 $C{$key} = {%{$A->{$key}}};
178 }
179 }
180  
181 bless \%C, ref($A);
182 }
183  
184 *sub = \&difference;
185 *diff = \&difference;
186  
187 sub symmetric_difference {
188 my ($A, $B) = @_;
189  
190 if (ref($B) ne __PACKAGE__) {
191 $B = $B->to_bag;
192 }
193  
194 my %C;
195  
196 foreach my $key (CORE::keys(%$A)) {
197 if (CORE::exists($B->{$key})) {
198  
199 my $h_A = $A->{$key};
200 my $h_B = $B->{$key};
201  
202 my $c_A = $h_A->{count};
203 my $c_B = $h_B->{count};
204  
205 if ($c_A > $c_B) {
206 $C{$key} = {
207 value => $h_A->{value},
208 count => $c_A - $c_B,
209 };
210 }
211 }
212 else {
213 $C{$key} = {%{$A->{$key}}};
214 }
215 }
216  
217 foreach my $key (CORE::keys(%$B)) {
218 if (CORE::exists($A->{$key})) {
219  
220 my $h_A = $A->{$key};
221 my $h_B = $B->{$key};
222  
223 my $c_A = $h_A->{count};
224 my $c_B = $h_B->{count};
225  
226 if ($c_B > $c_A) {
227 $C{$key} = {
228 value => $h_A->{value},
229 count => $c_B - $c_A,
230 };
231 }
232 }
233 else {
234 $C{$key} = {%{$B->{$key}}};
235 }
236 }
237  
238 bless \%C, ref($A);
239 }
240  
241 *xor = \&symmetric_difference;
242 *symdiff = \&symmetric_difference;
243  
244 sub append {
245 my ($self, @objects) = @_;
246  
247 foreach my $obj (@objects) {
248 my $key = $serialize->($obj);
249 ($self->{$key} //= {value => $obj})->{count}++;
250 }
251  
252 $self;
253 }
254  
255 *add = \&append;
256 *push = \&append;
257  
258 sub replace_pair {
259 my ($self, $obj, $n) = @_;
260  
261 my $count = CORE::int($n);
262 my $key = $serialize->($obj);
263  
264 $self->{$key} = {
265 value => $obj,
266 count => $count,
267 };
268  
269 $self;
270 }
271  
272 *set_kv = \&replace_pair;
273 *update_kv = \&replace_pair;
274 *update_pair = \&replace_pair;
275  
276 sub replace_pairs {
277 my ($self, @pairs) = @_;
278  
279 while (@pairs) {
280 my ($key, $value) = CORE::splice(@pairs, 0, 2);
281 $self->replace_pair($key, $value);
282 }
283  
284 $self;
285 }
286  
287 *set_kvs = \&replace_pairs;
288 *update_kvs = \&replace_pairs;
289 *update_pairs = \&replace_pairs;
290  
291 sub add_pair {
292 my ($self, $obj, $n) = @_;
293  
294 my $count = CORE::int($n);
295 my $key = $serialize->($obj);
296  
297 if (CORE::exists($self->{$key})) {
298 $self->{$key}{count} += $count;
299 }
300 else {
301 $self->{$key} = {
302 value => $obj,
303 count => $count,
304 };
305 }
306  
307 $self;
308 }
309  
310 *add_kv = \&add_pair;
311 *push_kv = \&add_pair;
312 *append_kv = \&add_pair;
313 *push_pair = \&add_pair;
314 *append_pair = \&add_pair;
315  
316 sub add_pairs {
317 my ($self, @pairs) = @_;
318  
319 while (@pairs) {
320 my ($key, $value) = CORE::splice(@pairs, 0, 2);
321 $self->add_pair($key, $value);
322 }
323  
324 $self;
325 }
326  
327 *add_kvs = \&add_pairs;
328 *push_kvs = \&add_pairs;
329 *append_kvs = \&add_pairs;
330 *push_pairs = \&add_pairs;
331 *append_pairs = \&add_pairs;
332  
333 sub pop {
334 my ($self) = @_;
335  
336 my $key = (CORE::keys(%$self))[-1] // return undef;
337 my $elem = $self->{$key};
338  
339 if ($elem->{count} > 1) {
340 --$elem->{count};
341 }
342 else {
343 CORE::delete($self->{$key});
344 }
345  
346 return $elem->{value};
347 }
348  
349 sub shift {
350 my ($self) = @_;
351  
352 my $key = (CORE::keys(%$self))[0] // return undef;
353 my $elem = $self->{$key};
354  
355 if ($elem->{count} > 1) {
356 --$elem->{count};
357 }
358 else {
359 CORE::delete($self->{$key});
360 }
361  
362 return $elem->{value};
363 }
364  
365 sub delete {
366 my ($self, @objects) = @_;
367  
368 my @values;
369 foreach my $obj (@objects) {
370 my $key = $serialize->($obj);
371  
372 if (CORE::exists($self->{$key})) {
373 my $elem = $self->{$key};
374 push @values, $elem->{value};
375  
376 if ($elem->{count} > 1) {
377 --$elem->{count};
378 }
379 else {
380 CORE::delete($self->{$key});
381 }
382 }
383 }
384  
385 return @values;
386 }
387  
388 *remove = \&delete;
389 *discard = \&delete;
390  
391 sub delete_all {
392 my ($self, @objects) = @_;
393 map { ($_->{value}) x $_->{count} } CORE::delete(@{$self}{map { $serialize->($_) } @objects});
394 }
395  
396 *remove_all = \&delete_all;
397 *discard_all = \&delete_all;
398  
399 sub delete_key {
400 my ($self, $obj) = @_;
401 my $key = $serialize->($obj);
402 my $elem = CORE::delete($self->{$key}) // return undef;
403 return $elem->{value};
404 }
405  
406 *remove_key = \&delete_key;
407 *discard_key = \&delete_key;
408  
409 sub map {
410 my ($self, $block) = @_;
411  
412 $block //= Sidef::Types::Block::Block::IDENTITY;
413  
414 my %new;
415 foreach my $key (CORE::keys(%$self)) {
416  
417 my $elem = $self->{$key};
418  
419 foreach my $value ($block->run($elem->{value})) {
420 ($new{$serialize->($value)} //= {value => $value})->{count} += $elem->{count};
421 }
422 }
423  
424 bless \%new, ref($self);
425 }
426  
427 sub map_2d {
428 my ($self, $block) = @_;
429  
430 $block //= Sidef::Types::Block::Block::ARRAY_IDENTITY;
431  
432 my %new;
433 foreach my $key (CORE::keys(%$self)) {
434  
435 my $elem = $self->{$key};
436  
437 foreach my $value ($block->run(@{$elem->{value}})) {
438 ($new{$serialize->($value)} //= {value => $value})->{count} += $elem->{count};
439 }
440 }
441  
442 bless \%new, ref($self);
443 }
444  
445 sub map_kv {
446 my ($self, $block) = @_;
447  
448 $block //= Sidef::Types::Block::Block::LIST_IDENTITY;
449  
450 my %new;
451 foreach my $key (CORE::keys(%$self)) {
452  
453 my $elem = $self->{$key};
454 my @pairs = $block->run($elem->{value}, Sidef::Types::Number::Number::_set_int($elem->{count}));
455  
456 while (@pairs) {
457 my $k = CORE::shift(@pairs);
458 my $v = CORE::int(CORE::shift(@pairs));
459  
460 if ($v > 0) {
461 $new{$serialize->($k)} = {value => $k, count => $v};
462 }
463 }
464 }
465  
466 bless \%new, ref($self);
467 }
468  
469 sub collect {
470 my ($self, $block) = @_;
471  
472 my @array;
473 foreach my $elem (CORE::values(%$self)) {
474 CORE::push(@array, ($block->run($elem->{value})) x $elem->{count});
475 }
476  
477 Sidef::Types::Array::Array->new(\@array);
478 }
479  
480 sub grep {
481 my ($self, $block) = @_;
482  
483 $block //= Sidef::Types::Block::Block::IDENTITY;
484  
485 my %new;
486 foreach my $key (CORE::keys(%$self)) {
487  
488 my $elem = $self->{$key};
489 my $value = $elem->{value};
490  
491 if ($block->run($value)) {
492 $new{$key} = {
493 value => $value,
494 count => $elem->{count},
495 };
496 }
497 }
498  
499 bless \%new, ref($self);
500 }
501  
502 *select = \&grep;
503  
504 sub grep_2d {
505 my ($self, $block) = @_;
506  
507 my %new;
508 foreach my $key (CORE::keys(%$self)) {
509  
510 my $elem = $self->{$key};
511 my $value = $elem->{value};
512  
513 if ($block->run(@$value)) {
514 $new{$key} = {
515 value => $value,
516 count => $elem->{count},
517 };
518 }
519 }
520  
521 bless \%new, ref($self);
522 }
523  
524 sub grep_kv {
525 my ($self, $block) = @_;
526  
527 my %new;
528 foreach my $key (CORE::keys(%$self)) {
529  
530 my $elem = $self->{$key};
531 my $value = $elem->{value};
532  
533 if ($block->run($value, Sidef::Types::Number::Number::_set_int($elem->{count}))) {
534 $new{$key} = {
535 value => $value,
536 count => $elem->{count},
537 };
538 }
539 }
540  
541 bless \%new, ref($self);
542 }
543  
544 sub count_by {
545 my ($self, $block) = @_;
546  
547 my $count = 0;
548 foreach my $elem (CORE::values(%$self)) {
549 if ($block->run($elem->{value})) {
550 $count += $elem->{count};
551 }
552 }
553  
554 Sidef::Types::Number::Number::_set_int($count);
555 }
556  
557 sub count {
558 my ($self, $obj) = @_;
559  
560 if (ref($obj) eq 'Sidef::Types::Block::Block') {
561 goto &count_by;
562 }
563  
564 my $key = $serialize->($obj);
565 if (CORE::exists($self->{$key})) {
566 return Sidef::Types::Number::Number::_set_int($self->{$key}{count});
567 }
568  
569 return Sidef::Types::Number::Number::ZERO;
570 }
571  
572 *get = \&count;
573  
574 sub delete_if {
575 my ($self, $block) = @_;
576  
577 foreach my $key (CORE::keys(%$self)) {
578 if ($block->run($self->{$key}{value})) {
579 CORE::delete($self->{$key});
580 }
581 }
582  
583 $self;
584 }
585  
586 sub delete_first_if {
587 my ($self, $block) = @_;
588  
589 foreach my $key (CORE::keys(%$self)) {
590 if ($block->run($self->{$key})) {
591  
592 my $elem = $self->{$key};
593  
594 if ($elem->{count} > 1) {
595 --$elem->{count};
596 }
597 else {
598 CORE::delete($self->{$key});
599 }
600  
601 last;
602 }
603 }
604  
605 $self;
606 }
607  
608 sub scale {
609 my ($self, $factor) = @_;
610 $factor = CORE::int($factor // 1);
611 my %new;
612 foreach my $key (CORE::keys(%$self)) {
613 my $elem = $self->{$key};
614 $new{$key} = {value => $elem->{value}, count => CORE::int($elem->{count} * $factor)};
615 }
616 bless \%new, ref($self);
617 }
618  
619 sub freq {
620 my ($self) = @_;
621 Sidef::Types::Array::Array->new(map { Sidef::Types::Array::Array->new([$_->{value}, Sidef::Types::Number::Number::_set_int($_->{count})]) }
622 CORE::values(%$self));
623 }
624  
625 sub relative_frequencies {
626 my ($self) = @_;
627 my $total = $self->length;
628 Sidef::Types::Array::Array->new(
629 [map { Sidef::Types::Array::Array->new([$_->{value}, Sidef::Types::Number::Number::_set_int($_->{count})->div($total)]) } CORE::values(%$self)]);
630 }
631  
632 sub variety {
633 my ($self) = @_;
634 my $total = $self->length;
635 $total->is_zero and return Sidef::Types::Number::Number::ZERO;
636 $self->elems->div($total);
637 }
638  
639 sub most_common {
640 my ($self, $n) = @_;
641  
642 $n //= Sidef::Types::Number::Number::ONE;
643  
644 my @sorted = sort { $b->{count} <=> $a->{count} } CORE::values(%$self);
645 my @top = splice(@sorted, 0, CORE::int($n));
646  
647 Sidef::Types::Array::Array->new(map { Sidef::Types::Array::Array->new([$_->{value}, Sidef::Types::Number::Number::_set_int($_->{count})]) } @top);
648 }
649  
650 *top = \&most_common;
651  
652 sub mode {
653 my ($self) = @_;
654 my ($best_key, $best_count);
655 foreach my $key (CORE::keys(%$self)) {
656 my $count = $self->{$key}{count};
657 if (!defined($best_count) or $count > $best_count) {
658 $best_count = $count;
659 $best_key = $key;
660 }
661 }
662 defined($best_key) ? $self->{$best_key}{value} : undef;
663 }
664  
665 sub uniq {
666 my ($self) = @_;
667  
668 my %new;
669  
670 foreach my $key (CORE::keys(%$self)) {
671 $new{$key} = {
672 value => $self->{$key}{value},
673 count => 1
674 };
675 }
676  
677 bless \%new, ref($self);
678 }
679  
680 *unique = \&uniq;
681  
682 sub iter {
683 my ($self) = @_;
684  
685 my $i = 0;
686 my @values = CORE::values(%$self);
687  
688 Sidef::Types::Block::Block->new(
689 code => sub {
690 my $elem = $values[$i++] // return undef;
691 Sidef::Types::Array::Array->new([$elem->{value}, Sidef::Types::Number::Number::_set_int($elem->{count})]);
692 }
693 );
694 }
695  
696 sub each {
697 my ($self, $block) = @_;
698  
699 foreach my $elem (CORE::values(%$self)) {
700 my $value = $elem->{value};
701 foreach my $i (1 .. $elem->{count}) {
702 $block->run($value);
703 }
704 }
705  
706 $self;
707 }
708  
709 sub each_2d {
710 my ($self, $block) = @_;
711  
712 foreach my $elem (CORE::values(%$self)) {
713 my $value = $elem->{value};
714 foreach my $i (1 .. $elem->{count}) {
715 $block->run(@$value);
716 }
717 }
718  
719 $self;
720 }
721  
722 sub each_kv {
723 my ($self, $block) = @_;
724  
725 foreach my $elem (CORE::values(%$self)) {
726 $block->run($elem->{value}, Sidef::Types::Number::Number::_set_int($elem->{count}));
727 }
728  
729 $self;
730 }
731  
732 sub length {
733 my ($self) = @_;
734  
735 my $len = 0;
736 foreach my $elem (CORE::values(%$self)) {
737 $len += $elem->{count};
738 }
739  
740 Sidef::Types::Number::Number::_set_int($len);
741 }
742  
743 *len = \&length;
744 *size = \&length;
745  
746 sub elems {
747 my ($self) = @_;
748 Sidef::Types::Number::Number::_set_int(scalar CORE::keys(%$self));
749 }
750  
751 *keys_len = \&elems;
752  
753 sub sort_by {
754 my ($self, $block) = @_;
755 $self->expand->sort_by($block);
756 }
757  
758 sub sort {
759 my ($self, $block) = @_;
760 $self->expand->sort(defined($block) ? $block : ());
761 }
762  
763 sub min {
764 my ($self) = @_;
765 $self->keys->min;
766 }
767  
768 sub max {
769 my ($self) = @_;
770 $self->keys->max;
771 }
772  
773 sub max_by {
774 my ($self, $block) = @_;
775 $self->keys->max_by($block);
776 }
777  
778 sub min_by {
779 my ($self, $block) = @_;
780 $self->keys->min_by($block);
781 }
782  
783 sub has {
784 my ($self, $obj) = @_;
785 my $key = $serialize->($obj);
786  
787 CORE::exists($self->{$key})
788 ? (Sidef::Types::Bool::Bool::TRUE)
789 : (Sidef::Types::Bool::Bool::FALSE);
790 }
791  
792 *haskey = \&has;
793 *has_key = \&has;
794 *exists = \&has;
795 *include = \&has;
796 *includes = \&has;
797 *contain = \&has;
798 *contains = \&has;
799  
800 sub is_subset {
801 my ($A, $B) = @_;
802  
803 if (ref($B) ne __PACKAGE__) {
804 $B = $B->to_bag;
805 }
806  
807 foreach my $key (CORE::keys(%$A)) {
808 if (!CORE::exists($B->{$key}) or $B->{$key}{count} < $A->{$key}{count}) {
809 return Sidef::Types::Bool::Bool::FALSE;
810 }
811 }
812  
813 return Sidef::Types::Bool::Bool::TRUE;
814 }
815  
816 sub is_superset {
817 my ($A, $B) = @_;
818  
819 if (ref($B) ne __PACKAGE__) {
820 $B = $B->to_bag;
821 }
822  
823 foreach my $key (CORE::keys(%$B)) {
824 if (!CORE::exists($A->{$key}) or $A->{$key}{count} < $B->{$key}{count}) {
825 return Sidef::Types::Bool::Bool::FALSE;
826 }
827 }
828  
829 return Sidef::Types::Bool::Bool::TRUE;
830 }
831  
832 sub contains_all {
833 my ($self, @objects) = @_;
834 __PACKAGE__->new(@objects)->is_subset($self);
835 }
836  
837 sub join {
838 my ($self, @rest) = @_;
839 $self->to_a->join(@rest);
840 }
841  
842 sub to_a {
843 my ($self) = @_;
844 ref($self) || return Sidef::Types::Array::Array->new($self);
845 Sidef::Types::Array::Array->new([map { ($_->{value}) x $_->{count} } CORE::values(%$self)]);
846 }
847  
848 *to_array = \&to_a;
849 *expand = \&to_a;
850  
851 sub to_h {
852 my ($self) = @_;
853 Sidef::Types::Hash::Hash->new(map { ($_->{value} => Sidef::Types::Number::Number::_set_int($_->{count})) } CORE::values(%$self));
854 }
855  
856 sub keys {
857 my ($self) = @_;
858 Sidef::Types::Array::Array->new([map { $_->{value} } CORE::values(%$self)]);
859 }
860  
861 sub values {
862 my ($self) = @_;
863 Sidef::Types::Array::Array->new([map { Sidef::Types::Number::Number::_set_int($_->{count}) } CORE::values(%$self)]);
864 }
865  
866 sub pairs {
867 my ($self) = @_;
868 Sidef::Types::Array::Array->new(
869 [map { Sidef::Types::Array::Pair->new($_->{value}, Sidef::Types::Number::Number::_set_int($_->{count})) } CORE::values(%$self)]);
870 }
871  
872 *kv = \&pairs;
873  
874 sub to_list {
875 my ($self) = @_;
876 map { ($_->{value}) x $_->{count} } CORE::values(%$self);
877 }
878  
879 sub to_set {
880 my ($self) = @_;
881 bless {map { $_ => $self->{$_}{value} } CORE::keys(%$self)}, 'Sidef::Types::Set::Set';
882 }
883  
884 sub to_bag {
885 $_[0];
886 }
887  
888 sub clone {
889 my ($self) = @_;
890  
891 my %new;
892 foreach my $key (CORE::keys(%$self)) {
893 $new{$key} = {%{$self->{$key}}};
894 }
895  
896 bless \%new, ref($self);
897 }
898  
899 sub eq {
900 my ($self, $hash) = @_;
901  
902 my %addr; # support for cyclic references
903  
904 my $sub = sub {
905 my ($h1, $h2) = @_;
906  
907 scalar(CORE::keys(%$h1)) == scalar(CORE::keys(%$h2))
908 or return (Sidef::Types::Bool::Bool::FALSE);
909  
910 my $refaddr1 = Scalar::Util::refaddr($h1);
911 my $refaddr2 = Scalar::Util::refaddr($h2);
912  
913 if ($refaddr1 == $refaddr2) {
914 return Sidef::Types::Bool::Bool::TRUE;
915 }
916  
917 CORE::exists($addr{$refaddr1})
918 and return $addr{$refaddr1};
919  
920 CORE::exists($addr{$refaddr2})
921 and return $addr{$refaddr2};
922  
923 $addr{$refaddr1} = Sidef::Types::Bool::Bool::FALSE;
924 $addr{$refaddr2} = Sidef::Types::Bool::Bool::FALSE;
925  
926 foreach my $key (CORE::keys(%$h1)) {
927  
928 CORE::exists($h2->{$key})
929 or return (Sidef::Types::Bool::Bool::FALSE);
930  
931 my $t1 = $h1->{$key};
932 my $t2 = $h2->{$key};
933  
934 ($t1->{count} == $t2->{count} and $t1->{value} eq $t2->{value})
935 or return (Sidef::Types::Bool::Bool::FALSE);
936 }
937  
938 (Sidef::Types::Bool::Bool::TRUE);
939 };
940  
941 no strict 'refs';
942 no warnings 'redefine';
943  
944 local *{__PACKAGE__ . '::' . 'eq'} = $sub;
945 local *{__PACKAGE__ . '::' . '=='} = $sub;
946 $sub->($self, $hash);
947 }
948  
949 sub ne {
950 my ($self, $obj) = @_;
951 $self->eq($obj)->not;
952 }
953  
954 sub _dump {
955 my %addr; # keeps track of dumped objects
956  
957 my $sub = sub {
958 my ($obj) = @_;
959  
960 my $refaddr = Scalar::Util::refaddr($obj);
961  
962 CORE::exists($addr{$refaddr})
963 and return $addr{$refaddr};
964  
965 my @values = CORE::values(%$obj);
966  
967 $addr{$refaddr} = "Bag(#`($refaddr)...)";
968  
969 my ($s, $v);
970 "Bag("
971 . CORE::join(', ', map { ((ref($v = $_->{value}) && ($s = UNIVERSAL::can($v, 'dump'))) ? $s->($v) : ($v // 'nil')) x $_->{count} } @values) . ')';
972 };
973  
974 no warnings 'redefine';
975 local *Sidef::Types::Set::Bag::dump = $sub;
976 $sub->($_[0]);
977 }
978  
979 sub dump {
980 Sidef::Types::String::String->new($_[0]->_dump);
981 }
982  
983 {
984 no strict 'refs';
985  
986 *{__PACKAGE__ . '::' . '+'} = \&concat;
987 *{__PACKAGE__ . '::' . '∪'} = \&union;
988 *{__PACKAGE__ . '::' . '|'} = \&union;
989 *{__PACKAGE__ . '::' . '&'} = \&intersection;
990 *{__PACKAGE__ . '::' . '∩'} = \&intersection;
991 *{__PACKAGE__ . '::' . '-'} = \&difference;
992 *{__PACKAGE__ . '::' . '∖'} = \&difference;
993 *{__PACKAGE__ . '::' . '^'} = \&symmetric_difference;
994 *{__PACKAGE__ . '::' . '<='} = \&is_subset;
995 *{__PACKAGE__ . '::' . '≤'} = \&is_subset;
996 *{__PACKAGE__ . '::' . '>='} = \&is_superset;
997 *{__PACKAGE__ . '::' . '≥'} = \&is_superset;
998 *{__PACKAGE__ . '::' . '⊆'} = \&is_subset;
999 *{__PACKAGE__ . '::' . '⊇'} = \&is_superset;
1000 *{__PACKAGE__ . '::' . '...'} = \&to_list;
1001 *{__PACKAGE__ . '::' . '≡'} = \&eq;
1002 *{__PACKAGE__ . '::' . '=='} = \&eq;
1003 *{__PACKAGE__ . '::' . '≠'} = \&ne;
1004 *{__PACKAGE__ . '::' . '!='} = \&ne;
1005 *{__PACKAGE__ . '::' . '<<'} = \&append;
1006 *{__PACKAGE__ . '::' . '∋'} = \&contains;
1007 *{__PACKAGE__ . '::' . '∌'} = sub { $_[0]->contains($_[1])->not };
1008 }
1009  
1010 1