Sidef/Types/Set/Set.pm untested

filter: Statementstmt 0.0% 0 / 351 Branchbran 0.0% 0 / 60 Conditioncond 0.0% 0 / 45 MC/DCmcdc 0.0% 0 / 27 Subroutinesub 0.0% 0 / 64 Podpod 0.0% 0 / 53 totaltotal 0.0% 0 / 600 CC 29 SCAR 16.5
CC
29
Cov
0%
count
12.0
is_subset
12.0
is_superset
12.0
CRAP 5.2
1 package Sidef::Types::Set::Set;
2  
3 use utf8;
4 use 5.016;
5  
6 use parent qw(
7 Sidef::Types::Hash::Hash
8 );
9  
10 use overload
11 q{bool} => sub { scalar(CORE::keys(%{$_[0]})) },
12 q{0+} => sub { scalar(CORE::keys(%{$_[0]})) },
13 q{@{}} => sub { [CORE::values(%{$_[0]})] },
14 q{""} => \&_dump;
15  
16 use List::Util qw();
17 use Sidef::Types::Block::Block;
18 use Sidef::Types::Bool::Bool;
19 use Sidef::Types::Number::Number;
20  
21 my $serialize = sub {
22 my ($obj) = @_;
23 my $key = ref($obj) ? (UNIVERSAL::can($obj, 'dump') ? $obj->dump : $obj) : ($obj // 'nil');
24 "$key";
25 };
26  
27 sub new {
28 my (undef, @objects) = @_;
29 bless {map { $serialize->($_) => $_ } @objects};
30 }
31  
32 *call = \&new;
33  
34 sub get_value {
35 my %addr;
36  
37 my $sub = sub {
38 my ($obj) = @_;
39  
40 my $refaddr = Scalar::Util::refaddr($obj);
41  
42 exists($addr{$refaddr})
43 && return $addr{$refaddr};
44  
45 my @set;
46 $addr{$refaddr} = \@set;
47  
48 foreach my $v (CORE::values(%$obj)) {
49 CORE::push(@set, (index(ref($v), 'Sidef::') == 0) ? $v->get_value : $v);
50 }
51  
52 $addr{$refaddr};
53 };
54  
55 no warnings 'redefine';
56 local *Sidef::Types::Set::Set::get_value = $sub;
57 $sub->($_[0]);
58 }
59  
60 sub concat {
61 my ($A, $B) = @_;
62  
63 ref($A) eq ref($B)
64 ? bless({%$A, %$B}, ref($A))
65 : bless({%$A, $serialize->($B) => $B}, ref($A));
66 }
67  
68 sub union {
69 my ($A, $B) = @_;
70  
71 if (ref($B) ne __PACKAGE__) {
72 $B = $B->to_set;
73 }
74  
75 $A->SUPER::union($B);
76 }
77  
78 *or = \&union;
79  
80 sub intersection {
81 my ($A, $B) = @_;
82  
83 if (ref($B) ne __PACKAGE__) {
84 $B = $B->to_set;
85 }
86  
87 $A->SUPER::intersection($B);
88 }
89  
90 *and = \&intersection;
91  
92 sub difference {
93 my ($A, $B) = @_;
94  
95 if (ref($B) ne __PACKAGE__) {
96 $B = $B->to_set;
97 }
98  
99 $A->SUPER::difference($B);
100 }
101  
102 *sub = \&difference;
103 *diff = \&difference;
104  
105 sub symmetric_difference {
106 my ($A, $B) = @_;
107  
108 if (ref($B) ne __PACKAGE__) {
109 $B = $B->to_set;
110 }
111  
112 $A->SUPER::symmetric_difference($B);
113 }
114  
115 *xor = \&symmetric_difference;
116 *symdiff = \&symmetric_difference;
117  
118 sub append {
119 my ($self, @objects) = @_;
120  
121 foreach my $obj (@objects) {
122 my $key = $serialize->($obj);
123 $self->{$key} = $obj;
124 }
125  
126 $self;
127 }
128  
129 *add = \&append;
130 *push = \&append;
131  
132 sub pop {
133 my ($self) = @_;
134 CORE::delete(@{$self}{(CORE::keys(%$self))[-1]});
135 }
136  
137 sub shift {
138 my ($self) = @_;
139 CORE::delete(@{$self}{(CORE::keys(%$self))[0]});
140 }
141  
142 sub delete {
143 my ($self, @objects) = @_;
144 CORE::delete(@{$self}{map { $serialize->($_) } @objects});
145 }
146  
147 *remove = \&delete;
148 *discard = \&delete;
149  
150 sub map {
151 my ($self, $block) = @_;
152  
153 $block //= Sidef::Types::Block::Block::IDENTITY;
154  
155 my %new;
156 foreach my $key (CORE::keys(%$self)) {
157 foreach my $value ($block->run($self->{$key})) {
158 $new{$serialize->($value)} = $value;
159 }
160 }
161  
162 bless \%new, ref($self);
163 }
164  
165 sub map_2d {
166 my ($self, $block) = @_;
167  
168 $block //= Sidef::Types::Block::Block::ARRAY_IDENTITY;
169  
170 my %new;
171 foreach my $key (CORE::keys(%$self)) {
172 foreach my $value ($block->run(@{$self->{$key}})) {
173 $new{$serialize->($value)} = $value;
174 }
175 }
176  
177 bless \%new, ref($self);
178 }
179  
180 sub collect {
181 my ($self, $block) = @_;
182  
183 my @array;
184 foreach my $value (CORE::values(%$self)) {
185 CORE::push(@array, $block->run($value));
186 }
187  
188 Sidef::Types::Array::Array->new(\@array);
189 }
190  
191 sub grep {
192 my ($self, $block) = @_;
193  
194 $block //= Sidef::Types::Block::Block::IDENTITY;
195  
196 my %new;
197 foreach my $key (CORE::keys(%$self)) {
198 my $value = $self->{$key};
199 if ($block->run($value)) {
200 $new{$key} = $value;
201 }
202 }
203  
204 bless \%new, ref($self);
205 }
206  
207 *select = \&grep;
208  
209 sub grep_2d {
210 my ($self, $block) = @_;
211  
212 my %new;
213 foreach my $key (CORE::keys(%$self)) {
214 my $value = $self->{$key};
215 if ($block->run(@$value)) {
216 $new{$key} = $value;
217 }
218 }
219  
220 bless \%new, ref($self);
221 }
222  
223 sub count_by {
224 my ($self, $block) = @_;
225  
226 my $count = 0;
227 foreach my $value (CORE::values(%$self)) {
228 if ($block->run($value)) {
229 ++$count;
230 }
231 }
232  
233 Sidef::Types::Number::Number::_set_int($count);
234 }
235  
236 sub count {
237 my ($self, $obj) = @_;
238  
239 if (ref($obj) eq 'Sidef::Types::Block::Block') {
240 goto &count_by;
241 }
242  
243 my $key = $serialize->($obj);
244 if (CORE::exists($self->{$key})) {
245 return Sidef::Types::Number::Number::ONE;
246 }
247  
248 return Sidef::Types::Number::Number::ZERO;
249 }
250  
251 sub delete_if {
252 my ($self, $block) = @_;
253  
254 foreach my $key (CORE::keys(%$self)) {
255 if ($block->run($self->{$key})) {
256 CORE::delete($self->{$key});
257 }
258 }
259  
260 $self;
261 }
262  
263 sub delete_first_if {
264 my ($self, $block) = @_;
265  
266 foreach my $key (CORE::keys(%$self)) {
267 if ($block->run($self->{$key})) {
268 CORE::delete($self->{$key});
269 last;
270 }
271 }
272  
273 $self;
274 }
275  
276 sub iter {
277 my ($self) = @_;
278  
279 my $i = 0;
280 my @values = CORE::values(%$self);
281 Sidef::Types::Block::Block->new(
282 code => sub {
283 $values[$i++];
284 }
285 );
286 }
287  
288 sub each {
289 my ($self, $block) = @_;
290  
291 foreach my $value (CORE::values(%$self)) {
292 $block->run($value);
293 }
294  
295 $self;
296 }
297  
298 sub each_2d {
299 my ($self, $block) = @_;
300  
301 foreach my $value (CORE::values(%$self)) {
302 $block->run(@$value);
303 }
304  
305 $self;
306 }
307  
308 sub sort_by {
309 my ($self, $block) = @_;
310 $self->values->sort_by($block);
311 }
312  
313 sub sort {
314 my ($self, $block) = @_;
315 $self->values->sort(defined($block) ? $block : ());
316 }
317  
318 sub sample {
319 my ($self, $n) = @_;
320 my @values = CORE::values(%$self);
321 $n = defined($n) ? CORE::int($n) : 1;
322 my @shuffled = List::Util::shuffle(@values);
323 Sidef::Types::Array::Array->new([@shuffled[0 .. List::Util::min($n, scalar(@shuffled)) - 1]]);
324 }
325  
326 sub pick {
327 my ($self) = @_;
328 my @values = CORE::values(%$self);
329 @values or return undef;
330 $values[CORE::int(CORE::rand(scalar(@values)))];
331 }
332  
333 sub min {
334 my ($self) = @_;
335 $self->values->min;
336 }
337  
338 sub max {
339 my ($self) = @_;
340 $self->values->max;
341 }
342  
343 sub max_by {
344 my ($self, $block) = @_;
345 $self->values->max_by($block);
346 }
347  
348 sub min_by {
349 my ($self, $block) = @_;
350 $self->values->min_by($block);
351 }
352  
353 sub sum {
354 my ($self, $block) = @_;
355 $self->to_a->sum($block);
356 }
357  
358 *sum_by = \∑
359  
360 sub prod {
361 my ($self, $block) = @_;
362 $self->to_a->prod($block);
363 }
364  
365 *prod_by = \∏
366  
367 sub sum_2d {
368 my ($self, $block) = @_;
369 $self->to_a->sum_2d($block);
370 }
371  
372 sub prod_2d {
373 my ($self, $block) = @_;
374 $self->to_a->prod_2d($block);
375 }
376  
377 sub has {
378 my ($self, $obj) = @_;
379 my $key = $serialize->($obj);
380 CORE::exists($self->{$key})
381 ? (Sidef::Types::Bool::Bool::TRUE)
382 : (Sidef::Types::Bool::Bool::FALSE);
383 }
384  
385 *haskey = \&has;
386 *has_key = \&has;
387 *exists = \&has;
388 *include = \&has;
389 *includes = \&has;
390 *contain = \&has;
391 *contains = \&has;
392  
393 sub is_subset {
394 my ($A, $B) = @_;
395  
396 if (ref($B) ne __PACKAGE__) {
397 $B = $B->to_set;
398 }
399  
400 foreach my $key (CORE::keys(%$A)) {
401 if (!CORE::exists($B->{$key})) {
402 return Sidef::Types::Bool::Bool::FALSE;
403 }
404 }
405  
406 return Sidef::Types::Bool::Bool::TRUE;
407 }
408  
409 sub is_superset {
410 my ($A, $B) = @_;
411  
412 if (ref($B) ne __PACKAGE__) {
413 $B = $B->to_set;
414 }
415  
416 foreach my $key (CORE::keys(%$B)) {
417 if (!CORE::exists($A->{$key})) {
418 return Sidef::Types::Bool::Bool::FALSE;
419 }
420 }
421  
422 return Sidef::Types::Bool::Bool::TRUE;
423 }
424  
425 sub is_disjoint {
426 my ($A, $B) = @_;
427  
428 if (ref($B) ne __PACKAGE__) {
429 $B = $B->to_set;
430 }
431  
432 foreach my $key (CORE::keys(%$A)) {
433 CORE::exists($B->{$key})
434 and return Sidef::Types::Bool::Bool::FALSE;
435 }
436  
437 return Sidef::Types::Bool::Bool::TRUE;
438 }
439  
440 sub is_proper_subset {
441 my ($A, $B) = @_;
442  
443 if (ref($B) ne __PACKAGE__) {
444 $B = $B->to_set;
445 }
446  
447 ($A->is_subset($B) && !$A->eq($B))
448 ? Sidef::Types::Bool::Bool::TRUE
449 : Sidef::Types::Bool::Bool::FALSE;
450 }
451  
452 sub is_proper_superset {
453 my ($A, $B) = @_;
454  
455 if (ref($B) ne __PACKAGE__) {
456 $B = $B->to_set;
457 }
458  
459 ($A->is_superset($B) && !$A->eq($B))
460 ? Sidef::Types::Bool::Bool::TRUE
461 : Sidef::Types::Bool::Bool::FALSE;
462 }
463  
464 sub contains_all {
465 my ($self, @objects) = @_;
466  
467 foreach my $obj (@objects) {
468 if (!CORE::exists($self->{$serialize->($obj)})) {
469 return Sidef::Types::Bool::Bool::FALSE;
470 }
471 }
472  
473 return Sidef::Types::Bool::Bool::TRUE;
474 }
475  
476 sub powerset {
477 my ($self) = @_;
478 my @values = CORE::values(%$self);
479 my @subsets = ([]);
480 foreach my $v (@values) {
481 push @subsets, map { [@$_, $v] } @subsets;
482 }
483 Sidef::Types::Array::Array->new([map { __PACKAGE__->new(@$_) } @subsets]);
484 }
485  
486 sub join {
487 my ($self, @rest) = @_;
488 $self->to_a->join(@rest);
489 }
490  
491 sub all {
492 my ($self, $block) = @_;
493  
494 $block //= Sidef::Types::Block::Block::IDENTITY;
495  
496 foreach my $key (CORE::keys(%$self)) {
497 $block->run($self->{$key})
498 || return Sidef::Types::Bool::Bool::FALSE;
499 }
500  
501 Sidef::Types::Bool::Bool::TRUE;
502 }
503  
504 sub any {
505 my ($self, $block) = @_;
506  
507 $block //= Sidef::Types::Block::Block::IDENTITY;
508  
509 foreach my $key (CORE::keys(%$self)) {
510 $block->run($self->{$key})
511 && return Sidef::Types::Bool::Bool::TRUE;
512 }
513  
514 Sidef::Types::Bool::Bool::FALSE;
515 }
516  
517 sub none {
518 my ($self, $block) = @_;
519  
520 $block //= Sidef::Types::Block::Block::IDENTITY;
521  
522 foreach my $key (CORE::keys(%$self)) {
523 $block->run($self->{$key})
524 && return Sidef::Types::Bool::Bool::FALSE;
525 }
526  
527 Sidef::Types::Bool::Bool::TRUE;
528 }
529  
530 sub _dump {
531 my %addr; # keeps track of dumped objects
532  
533 my $sub = sub {
534 my ($obj) = @_;
535  
536 my $refaddr = Scalar::Util::refaddr($obj);
537  
538 exists($addr{$refaddr})
539 and return $addr{$refaddr};
540  
541 my @values = CORE::values(%$obj);
542  
543 $addr{$refaddr} = "Set(#`($refaddr)...)";
544  
545 my $s;
546 "Set(" . CORE::join(', ', map { (ref($_) && ($s = UNIVERSAL::can($_, 'dump'))) ? $s->($_) : ($_ // 'nil') } @values) . ')';
547 };
548  
549 no warnings 'redefine';
550 local *Sidef::Types::Set::Set::dump = $sub;
551 $sub->($_[0]);
552 }
553  
554 sub dump {
555 Sidef::Types::String::String->new($_[0]->_dump);
556 }
557  
558 sub to_a {
559 my ($self) = @_;
560 Sidef::Types::Array::Array->new(ref($self) ? [CORE::values(%$self)] : $self);
561 }
562  
563 *values = \&to_a;
564 *to_array = \&to_a;
565  
566 sub to_list {
567 my ($self) = @_;
568 CORE::values(%$self);
569 }
570  
571 sub to_bag {
572 my ($self) = @_;
573 Sidef::Types::Set::Bag->new(CORE::values(%$self));
574 }
575  
576 sub to_set {
577 $_[0];
578 }
579  
580 {
581 no strict 'refs';
582  
583 *{__PACKAGE__ . '::' . '+'} = \&concat;
584 *{__PACKAGE__ . '::' . '<<'} = \&append;
585 *{__PACKAGE__ . '::' . '∪'} = \&union;
586 *{__PACKAGE__ . '::' . '|'} = \&union;
587 *{__PACKAGE__ . '::' . '&'} = \&intersection;
588 *{__PACKAGE__ . '::' . '∩'} = \&intersection;
589 *{__PACKAGE__ . '::' . '-'} = \&difference;
590 *{__PACKAGE__ . '::' . '∖'} = \&difference;
591 *{__PACKAGE__ . '::' . '^'} = \&symmetric_difference;
592 *{__PACKAGE__ . '::' . '<='} = \&is_subset;
593 *{__PACKAGE__ . '::' . '≤'} = \&is_subset;
594 *{__PACKAGE__ . '::' . '>='} = \&is_superset;
595 *{__PACKAGE__ . '::' . '≥'} = \&is_superset;
596 *{__PACKAGE__ . '::' . '⊆'} = \&is_subset;
597 *{__PACKAGE__ . '::' . '⊇'} = \&is_superset;
598 *{__PACKAGE__ . '::' . '...'} = \&to_list;
599 *{__PACKAGE__ . '::' . '∋'} = \&contains;
600 *{__PACKAGE__ . '::' . '∌'} = sub { $_[0]->contains($_[1])->not };
601 *{__PACKAGE__ . '::' . '≡'} = \&Sidef::Types::Hash::Hash::eq;
602 }
603  
604 1