blib/lib/Venus/Collect.pm

filter: Statementstmt 98.9% 90 / 91 Branchbran 90.9% 20 / 22 Conditioncond 66.6% 16 / 24 MC/DCmcdc 50.0% 8 / 16 Subroutinesub 100% 15 / 15 Podpod 10.0% 1 / 10 totaltotal 84.2% 150 / 178 CC 21 SCAR 23.7
CC
21
Cov
92%
execute
19.2
iterate
4.0
BEGIN
1.0
CRAP 10.7
« blib/lib/Venus/Cli.pm ↑ Summary blib/lib/Venus/Set.pm »
1 package Venus::Collect;
2  
3 2 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 2 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 2 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # VENUS
9  
10 2 ▶use Venus::Class 'base', 'with';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # IMPORTS
13  
14 2 ▶use Venus 'list', 'pairs';
Subroutine BEGIN: called CC=1 SCAR=0.0
15  
16 # INHERITS
17  
18 2 base 'Venus::Kind::Utility';
19  
20 # INTEGRATES
21  
22 2 with 'Venus::Role::Valuable';
23  
24 # METHODS
25  
26 44 ▶sub execute {
Subroutine execute: called CC=18 SCAR=29.6
Pod documented
27 44 my ($self, $code) = @_;
28  
29 44 require Scalar::Util;
30  
31 44 my $value = $self->value;
32  
33 44 ▶ return $value if !$code;
Branch: 1 branch
BranchTrueFalseTotal
unless $code 10 34 44
34  
35 34 my $blessed = !!Scalar::Util::blessed($value);
36  
37 34 ▶ if (!$blessed && ref $value eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (not $blessed and ref $value eq "ARRAY") 5 29 34
Condition100%3/3
not $blessed and ref $value eq "ARRAY"
!ll&&!rl&&r
2455
MC/DC100%2/2
not $blessed and ref $value eq "ARRAY"
not $blessed ref $value eq "ARRAY"
Truth table100%3/3
not(A) and B
A= not $blessedB= ref $value eq "ARRAY"
ABresult
0X0
100
111
38 5 return $self->iterate_over_unblessed_arrayref($code, $value);
39 }
40  
41 29 ▶ if (!$blessed && ref $value eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (not $blessed and ref $value eq "HASH") 5 24 29
Condition66%2/3
not $blessed and ref $value eq "HASH"
!ll&&!rl&&r
2405
MC/DC50%1/2
not $blessed and ref $value eq "HASH"
not $blessed ref $value eq "HASH"
Truth table66%2/3
not(A) and B
A= not $blessedB= ref $value eq "HASH"
ABresult
0X0
100
111
42 5 return $self->iterate_over_unblessed_hashref($code, $value);
43 }
44  
45 24 ▶ if ($blessed && $value->isa('Venus::Array')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and $value->isa("Venus::Array")) 4 20 24
Condition66%2/3
$blessed and $value->isa("Venus::Array")
!ll&&!rl&&r
0204
MC/DC50%1/2
$blessed and $value->isa("Venus::Array")
$blessed $value->isa("Venus::Array")
Truth table66%2/3
A and B
A= $blessedB= $value->isa("Venus::Array")
ABresult
0X0
100
111
46 4 return $self->iterate_over_venus_array_object($code, $value);
47 }
48  
49 20 ▶ if ($blessed && $value->isa('Venus::Set')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and $value->isa("Venus::Set")) 4 16 20
Condition66%2/3
$blessed and $value->isa("Venus::Set")
!ll&&!rl&&r
0164
MC/DC50%1/2
$blessed and $value->isa("Venus::Set")
$blessed $value->isa("Venus::Set")
Truth table66%2/3
A and B
A= $blessedB= $value->isa("Venus::Set")
ABresult
0X0
100
111
50 4 return $self->iterate_over_venus_set_object($code, $value);
51 }
52  
53 16 ▶ if ($blessed && $value->isa('Venus::Hash')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and $value->isa("Venus::Hash")) 4 12 16
Condition66%2/3
$blessed and $value->isa("Venus::Hash")
!ll&&!rl&&r
0124
MC/DC50%1/2
$blessed and $value->isa("Venus::Hash")
$blessed $value->isa("Venus::Hash")
Truth table66%2/3
A and B
A= $blessedB= $value->isa("Venus::Hash")
ABresult
0X0
100
111
54 4 return $self->iterate_over_venus_hash_object($code, $value);
55 }
56  
57 12 ▶ if ($blessed && $value->isa('Venus::Map')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and $value->isa("Venus::Map")) 4 8 12
Condition66%2/3
$blessed and $value->isa("Venus::Map")
!ll&&!rl&&r
084
MC/DC50%1/2
$blessed and $value->isa("Venus::Map")
$blessed $value->isa("Venus::Map")
Truth table66%2/3
A and B
A= $blessedB= $value->isa("Venus::Map")
ABresult
0X0
100
111
58 4 return $self->iterate_over_venus_map_object($code, $value);
59 }
60  
61 8 ▶ if ($blessed && UNIVERSAL::isa($value, 'ARRAY')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and UNIVERSAL::isa($value, "ARRAY")) 4 4 8
Condition66%2/3
$blessed and UNIVERSAL::isa($value, "ARRAY")
!ll&&!rl&&r
044
MC/DC50%1/2
$blessed and UNIVERSAL::isa($value, "ARRAY")
$blessed UNIVERSAL::isa($value, "ARRAY")
Truth table66%2/3
A and B
A= $blessedB= UNIVERSAL::isa($value, "ARRAY")
ABresult
0X0
100
111
62 4 return $self->iterate_over_blessed_arrayref($code, $value);
63 }
64  
65 4 ▶ if ($blessed && UNIVERSAL::isa($value, 'HASH')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($blessed and UNIVERSAL::isa($value, "HASH")) 4 0 4
Condition33%1/3
$blessed and UNIVERSAL::isa($value, "HASH")
!ll&&!rl&&r
004
MC/DC0%0/2
$blessed and UNIVERSAL::isa($value, "HASH")
$blessed UNIVERSAL::isa($value, "HASH")
Truth table33%1/3
A and B
A= $blessedB= UNIVERSAL::isa($value, "HASH")
ABresult
0X0
100
111
66 4 return $self->iterate_over_blessed_hashref($code, $value);
67 }
68  
69 0 return $value;
70 }
71  
72 34 ▶sub iterate {
Subroutine iterate: called CC=4 SCAR=13.9
Pod undocumented
73 34 my ($self, $code, $pairs) = @_;
74  
75 34 my $result = [];
76  
77 34 for my $pair (list $pairs) {
78 136 my ($key, $value) = (list $pair);
79  
80 136 local $_ = $value;
81  
82 136 my @returned = list $code->($key, $value);
83  
84 136 ▶ push @{$result}, [@returned] if @returned == 2;
Branch: 1 branch
BranchTrueFalseTotal
if @returned == 2 47 89 136
85 }
86  
87 34 ▶ return wantarray ? @{$result} : $result;
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 34 0 34
88 }
89  
90 4 ▶sub iterate_over_blessed_arrayref {
Subroutine iterate_over_blessed_arrayref: called CC=1 SCAR=0.0
Pod undocumented
91 4 my ($self, $code, $value) = @_;
92  
93 4 my @results = $self->iterate($code, scalar pairs [@{$value}]);
94  
95 4 @results = map {$$_[1]} sort {$$a[0] <=> $$b[0]} @results;
96  
97 4 return bless [@results], ref $value;
98 }
99  
100 4 ▶sub iterate_over_blessed_hashref {
Subroutine iterate_over_blessed_hashref: called CC=1 SCAR=0.0
Pod undocumented
101 4 my ($self, $code, $value) = @_;
102  
103 4 my @results = $self->iterate($code, scalar pairs {%{$value}});
104  
105 4 @results = map +($$_[0], $$_[1]), @results;
106  
107 4 return bless {@results}, ref $value;
108 }
109  
110 5 ▶sub iterate_over_unblessed_arrayref {
Subroutine iterate_over_unblessed_arrayref: called CC=1 SCAR=0.0
Pod undocumented
111 5 my ($self, $code, $value) = @_;
112  
113 5 my @results = $self->iterate($code, scalar pairs $value);
114  
115 5 @results = map {$$_[1]} sort {$$a[0] <=> $$b[0]} @results;
116  
117 5 return [@results];
118 }
119  
120 5 ▶sub iterate_over_unblessed_hashref {
Subroutine iterate_over_unblessed_hashref: called CC=1 SCAR=0.0
Pod undocumented
121 5 my ($self, $code, $value) = @_;
122  
123 5 my @results = $self->iterate($code, scalar pairs $value);
124  
125 5 @results = map +($$_[0], $$_[1]), @results;
126  
127 5 return {@results};
128 }
129  
130 4 ▶sub iterate_over_venus_array_object {
Subroutine iterate_over_venus_array_object: called CC=1 SCAR=0.0
Pod undocumented
131 4 my ($self, $code, $value) = @_;
132  
133 4 my @results = $self->iterate($code, scalar $value->pairs);
134  
135 4 @results = map {$$_[1]} sort {$$a[0] <=> $$b[0]} @results;
136  
137 4 return $value->new(value => [@results]);
138 }
139  
140 4 ▶sub iterate_over_venus_hash_object {
Subroutine iterate_over_venus_hash_object: called CC=1 SCAR=0.0
Pod undocumented
141 4 my ($self, $code, $value) = @_;
142  
143 4 my @results = $self->iterate($code, scalar $value->pairs);
144  
145 4 @results = map +($$_[0], $$_[1]), @results;
146  
147 4 return $value->new(value => {@results});
148 }
149  
150 4 ▶sub iterate_over_venus_map_object {
Subroutine iterate_over_venus_map_object: called CC=1 SCAR=0.0
Pod undocumented
151 4 my ($self, $code, $value) = @_;
152  
153 4 my @results = $self->iterate($code, scalar $value->pairs);
154  
155 4 @results = map +($$_[0], $$_[1]), @results;
156  
157 4 return $value->renew(value => {@results});
158 }
159  
160 4 ▶sub iterate_over_venus_set_object {
Subroutine iterate_over_venus_set_object: called CC=1 SCAR=0.0
Pod undocumented
161 4 my ($self, $code, $value) = @_;
162  
163 4 my @results = $self->iterate($code, scalar $value->pairs);
164  
165 4 @results = map {$$_[1]} sort {$$a[0] <=> $$b[0]} @results;
166  
167 4 return $value->renew(value => [@results]);
168 }
169  
170 2 1;
171  
172  
173  
174 =head1 NAME
175  
176 Venus::Collect - Collect Class
177  
178 =cut
179  
180 =head1 ABSTRACT
181  
182 Collect Class for Perl 5
183  
184 =cut
185  
186 =head1 SYNOPSIS
187  
188 package main;
189  
190 use Venus::Collect;
191  
192 my $collect = Venus::Collect->new([1..4]);
193  
194 # bless({value => [1..4], 'Venus::Collect')
195  
196 =cut
197  
198 =head1 DESCRIPTION
199  
200 This package provides a generic collection utility class designed to provide a
201 unified interface for working with data collections in Perl. It can wrap native
202 Perl arrayrefs and hashrefs, as well as compatible objects (e.g.,
203 L<Venus::Array>, L<Venus::Hash>, L<Venus::Set>, etc.), and apply functional
204 transformations through callbacks.
205  
206 This class allows you to create a collection object, then use the C<execute>
207 method to iterate over the contents and selectively transform or filter the
208 data. The method supports both list-like and hash-like data structures,
209 handling key/value iteration when applicable.
210  
211 It's especially useful in scenarios where you need to apply consistent
212 processing logic across various collection types without writing boilerplate
213 code for each type.
214  
215 =cut
216  
217 =head1 INHERITS
218  
219 This package inherits behaviors from:
220  
221 L<Venus::Kind::Utility>
222  
223 =cut
224  
225 =head1 INTEGRATES
226  
227 This package integrates behaviors from:
228  
229 L<Venus::Role::Valuable>
230  
231 =cut
232  
233 =head1 METHODS
234  
235 This package provides the following methods:
236  
237 =cut
238  
239 =head2 execute
240  
241 execute(coderef $code) (any)
242  
243 The execute method accepts a callback (i.e. coderef) and executes the callback
244 for each key/value pair in the L</value>. For each iteration, the C<$_>
245 variable is set to the value (in the key/value pair). The callback will be
246 passed the key and values as arguments, made available via the C<@_> variable.
247 The callback must return a tuple, i.e. a list with the key and value, to be
248 returned as a result. This method returns a new instance of L</value> provided
249 consisting of only the key/value pairs returned from the callback.
250  
251 I<Since C<4.15>>
252  
253 =over 4
254  
255 =item execute example 1
256  
257 # given: synopsis
258  
259 package main;
260  
261 my $execute = $collect->execute;
262  
263 # [1..4]
264  
265 =back
266  
267 =over 4
268  
269 =item execute example 2
270  
271 # given: synopsis
272  
273 package main;
274  
275 my $execute = $collect->execute(sub{});
276  
277 # []
278  
279 =back
280  
281 =over 4
282  
283 =item execute example 3
284  
285 # given: synopsis
286  
287 package main;
288  
289 my $execute = $collect->execute(sub{$_});
290  
291 # []
292  
293 =back
294  
295 =over 4
296  
297 =item execute example 4
298  
299 # given: synopsis
300  
301 package main;
302  
303 my $execute = $collect->execute(sub{@_});
304  
305 # [1..4]
306  
307 =back
308  
309 =over 4
310  
311 =item execute example 5
312  
313 # given: synopsis
314  
315 package main;
316  
317 my $execute = $collect->execute(sub{$_%2==0 ? (@_) : ()});
318  
319 # [2,4]
320  
321 =back
322  
323 =over 4
324  
325 =item execute example 6
326  
327 package main;
328  
329 use Venus::Collect;
330  
331 my $collect = Venus::Collect->new(value => {1..8});
332  
333 my $execute = $collect->execute;
334  
335 # {1..8}
336  
337 =back
338  
339 =over 4
340  
341 =item execute example 7
342  
343 package main;
344  
345 use Venus::Collect;
346  
347 my $collect = Venus::Collect->new(value => {1..8});
348  
349 my $execute = $collect->execute(sub{});
350  
351 # {}
352  
353 =back
354  
355 =over 4
356  
357 =item execute example 8
358  
359 package main;
360  
361 use Venus::Collect;
362  
363 my $collect = Venus::Collect->new(value => {1..8});
364  
365 my $execute = $collect->execute(sub{$_});
366  
367 # {}
368  
369 =back
370  
371 =over 4
372  
373 =item execute example 9
374  
375 package main;
376  
377 use Venus::Collect;
378  
379 my $collect = Venus::Collect->new(value => {1..8});
380  
381 my $execute = $collect->execute(sub{@_});
382  
383 # {1..8}
384  
385 =back
386  
387 =over 4
388  
389 =item execute example 10
390  
391 package main;
392  
393 use Venus::Collect;
394  
395 my $collect = Venus::Collect->new(value => {1..8});
396  
397 my $execute = $collect->execute(sub{$_%6==0 ? (@_) : ()});
398  
399 # {5,6}
400  
401 =back
402  
403 =over 4
404  
405 =item execute example 11
406  
407 package main;
408  
409 use Venus::Collect;
410 use Venus::Array;
411  
412 my $value = Venus::Array->new([1..4]);
413  
414 my $collect = Venus::Collect->new(value => $value);
415  
416 my $execute = $collect->execute;
417  
418 # bless({value => [1..4], 'Venus::Array')
419  
420 =back
421  
422 =over 4
423  
424 =item execute example 12
425  
426 package main;
427  
428 use Venus::Collect;
429 use Venus::Array;
430  
431 my $value = Venus::Array->new([1..4]);
432  
433 my $collect = Venus::Collect->new(value => $value);
434  
435 my $execute = $collect->execute(sub{});
436  
437 # bless({value => [], 'Venus::Array')
438  
439 =back
440  
441 =over 4
442  
443 =item execute example 13
444  
445 package main;
446  
447 use Venus::Collect;
448 use Venus::Array;
449  
450 my $value = Venus::Array->new([1..4]);
451  
452 my $collect = Venus::Collect->new(value => $value);
453  
454 my $execute = $collect->execute(sub{$_});
455  
456 # bless({value => [], 'Venus::Array')
457  
458 =back
459  
460 =over 4
461  
462 =item execute example 14
463  
464 package main;
465  
466 use Venus::Collect;
467 use Venus::Array;
468  
469 my $value = Venus::Array->new([1..4]);
470  
471 my $collect = Venus::Collect->new(value => $value);
472  
473 my $execute = $collect->execute(sub{@_});
474  
475 # bless({value => [1..4], 'Venus::Array')
476  
477 =back
478  
479 =over 4
480  
481 =item execute example 15
482  
483 package main;
484  
485 use Venus::Collect;
486 use Venus::Array;
487  
488 my $value = Venus::Array->new([1..4]);
489  
490 my $collect = Venus::Collect->new(value => $value);
491  
492 my $execute = $collect->execute(sub{$_%2==0 ? (@_) : ()});
493  
494 # bless({value => [2,4], 'Venus::Array')
495  
496 =back
497  
498 =over 4
499  
500 =item execute example 16
501  
502 package main;
503  
504 use Venus::Collect;
505 use Venus::Set;
506  
507 my $value = Venus::Set->new([1..4]);
508  
509 my $collect = Venus::Collect->new(value => $value);
510  
511 my $execute = $collect->execute;
512  
513 # bless({value => [1..4], 'Venus::Set')
514  
515 =back
516  
517 =over 4
518  
519 =item execute example 17
520  
521 package main;
522  
523 use Venus::Collect;
524 use Venus::Set;
525  
526 my $value = Venus::Set->new([1..4]);
527  
528 my $collect = Venus::Collect->new(value => $value);
529  
530 my $execute = $collect->execute(sub{});
531  
532 # bless({value => [], 'Venus::Set')
533  
534 =back
535  
536 =over 4
537  
538 =item execute example 18
539  
540 package main;
541  
542 use Venus::Collect;
543 use Venus::Set;
544  
545 my $value = Venus::Set->new([1..4]);
546  
547 my $collect = Venus::Collect->new(value => $value);
548  
549 my $execute = $collect->execute(sub{$_});
550  
551 # bless({value => [], 'Venus::Set')
552  
553 =back
554  
555 =over 4
556  
557 =item execute example 19
558  
559 package main;
560  
561 use Venus::Collect;
562 use Venus::Set;
563  
564 my $value = Venus::Set->new([1..4]);
565  
566 my $collect = Venus::Collect->new(value => $value);
567  
568 my $execute = $collect->execute(sub{@_});
569  
570 # bless({value => [1..4], 'Venus::Set')
571  
572 =back
573  
574 =over 4
575  
576 =item execute example 20
577  
578 package main;
579  
580 use Venus::Collect;
581 use Venus::Set;
582  
583 my $value = Venus::Set->new([1..4]);
584  
585 my $collect = Venus::Collect->new(value => $value);
586  
587 my $execute = $collect->execute(sub{$_%2==0 ? (@_) : ()});
588  
589 # bless({value => [2,4], 'Venus::Set')
590  
591 =back
592  
593 =over 4
594  
595 =item execute example 21
596  
597 package main;
598  
599 use Venus::Collect;
600 use Venus::Hash;
601  
602 my $value = Venus::Hash->new(value => {1..8});
603  
604 my $collect = Venus::Collect->new(value => $value);
605  
606 my $execute = $collect->execute;
607  
608 # bless({value => {1..8}, 'Venus::Hash')
609  
610 =back
611  
612 =over 4
613  
614 =item execute example 22
615  
616 package main;
617  
618 use Venus::Collect;
619 use Venus::Hash;
620  
621 my $value = Venus::Hash->new(value => {1..8});
622  
623 my $collect = Venus::Collect->new(value => $value);
624  
625 my $execute = $collect->execute(sub{});
626  
627 # bless({value => {}, 'Venus::Hash')
628  
629 =back
630  
631 =over 4
632  
633 =item execute example 23
634  
635 package main;
636  
637 use Venus::Collect;
638 use Venus::Hash;
639  
640 my $value = Venus::Hash->new(value => {1..8});
641  
642 my $collect = Venus::Collect->new(value => $value);
643  
644 my $execute = $collect->execute(sub{$_});
645  
646 # bless({value => {}, 'Venus::Hash')
647  
648 =back
649  
650 =over 4
651  
652 =item execute example 24
653  
654 package main;
655  
656 use Venus::Collect;
657 use Venus::Hash;
658  
659 my $value = Venus::Hash->new(value => {1..8});
660  
661 my $collect = Venus::Collect->new(value => $value);
662  
663 my $execute = $collect->execute(sub{@_});
664  
665 # bless({value => {1..8}, 'Venus::Hash')
666  
667 =back
668  
669 =over 4
670  
671 =item execute example 25
672  
673 package main;
674  
675 use Venus::Collect;
676 use Venus::Hash;
677  
678 my $value = Venus::Hash->new(value => {1..8});
679  
680 my $collect = Venus::Collect->new(value => $value);
681  
682 my $execute = $collect->execute(sub{$_%6==0 ? (@_) : ()});
683  
684 # bless({value => {5,6}, 'Venus::Hash')
685  
686 =back
687  
688 =over 4
689  
690 =item execute example 26
691  
692 package main;
693  
694 use Venus::Collect;
695 use Venus::Map;
696  
697 my $value = Venus::Map->new(value => {1..8});
698  
699 my $collect = Venus::Collect->new(value => $value);
700  
701 my $execute = $collect->execute;
702  
703 # bless({value => {1..8}, 'Venus::Map')
704  
705 =back
706  
707 =over 4
708  
709 =item execute example 27
710  
711 package main;
712  
713 use Venus::Collect;
714 use Venus::Map;
715  
716 my $value = Venus::Map->new(value => {1..8});
717  
718 my $collect = Venus::Collect->new(value => $value);
719  
720 my $execute = $collect->execute(sub{});
721  
722 # bless({value => {}, 'Venus::Map')
723  
724 =back
725  
726 =over 4
727  
728 =item execute example 28
729  
730 package main;
731  
732 use Venus::Collect;
733 use Venus::Map;
734  
735 my $value = Venus::Map->new(value => {1..8});
736  
737 my $collect = Venus::Collect->new(value => $value);
738  
739 my $execute = $collect->execute(sub{$_});
740  
741 # bless({value => {}, 'Venus::Map')
742  
743 =back
744  
745 =over 4
746  
747 =item execute example 29
748  
749 package main;
750  
751 use Venus::Collect;
752 use Venus::Map;
753  
754 my $value = Venus::Map->new(value => {1..8});
755  
756 my $collect = Venus::Collect->new(value => $value);
757  
758 my $execute = $collect->execute(sub{@_});
759  
760 # bless({value => {1..8}, 'Venus::Map')
761  
762 =back
763  
764 =over 4
765  
766 =item execute example 30
767  
768 package main;
769  
770 use Venus::Collect;
771 use Venus::Map;
772  
773 my $value = Venus::Map->new(value => {1..8});
774  
775 my $collect = Venus::Collect->new(value => $value);
776  
777 my $execute = $collect->execute(sub{$_%6==0 ? (@_) : ()});
778  
779 # bless({value => {5,6}, 'Venus::Map')
780  
781 =back
782  
783 =over 4
784  
785 =item execute example 31
786  
787 package main;
788  
789 use Venus::Collect;
790  
791 my $value = bless [1..4], 'Example';
792  
793 my $collect = Venus::Collect->new(value => $value);
794  
795 my $execute = $collect->execute;
796  
797 # bless([1..4], 'Example')
798  
799 =back
800  
801 =over 4
802  
803 =item execute example 32
804  
805 package main;
806  
807 use Venus::Collect;
808  
809 my $value = bless [1..4], 'Example';
810  
811 my $collect = Venus::Collect->new(value => $value);
812  
813 my $execute = $collect->execute(sub{});
814  
815 # bless([], 'Example')
816  
817 =back
818  
819 =over 4
820  
821 =item execute example 33
822  
823 package main;
824  
825 use Venus::Collect;
826  
827 my $value = bless [1..4], 'Example';
828  
829 my $collect = Venus::Collect->new(value => $value);
830  
831 my $execute = $collect->execute(sub{$_});
832  
833 # bless([], 'Example')
834  
835 =back
836  
837 =over 4
838  
839 =item execute example 34
840  
841 package main;
842  
843 use Venus::Collect;
844  
845 my $value = bless [1..4], 'Example';
846  
847 my $collect = Venus::Collect->new(value => $value);
848  
849 my $execute = $collect->execute(sub{@_});
850  
851 # bless([1..4], 'Example')
852  
853 =back
854  
855 =over 4
856  
857 =item execute example 35
858  
859 package main;
860  
861 use Venus::Collect;
862  
863 my $value = bless [1..4], 'Example';
864  
865 my $collect = Venus::Collect->new(value => $value);
866  
867 my $execute = $collect->execute(sub{$_%2==0 ? (@_) : ()});
868  
869 # bless([2,4], 'Example')
870  
871 =back
872  
873 =over 4
874  
875 =item execute example 36
876  
877 package main;
878  
879 use Venus::Collect;
880  
881 my $value = bless {1..8}, 'Example';
882  
883 my $collect = Venus::Collect->new(value => $value);
884  
885 my $execute = $collect->execute;
886  
887 # bless({1..8}, 'Example')
888  
889 =back
890  
891 =over 4
892  
893 =item execute example 37
894  
895 package main;
896  
897 use Venus::Collect;
898  
899 my $value = bless {1..8}, 'Example';
900  
901 my $collect = Venus::Collect->new(value => $value);
902  
903 my $execute = $collect->execute(sub{});
904  
905 # bless({}, 'Example')
906  
907 =back
908  
909 =over 4
910  
911 =item execute example 38
912  
913 package main;
914  
915 use Venus::Collect;
916  
917 my $value = bless {1..8}, 'Example';
918  
919 my $collect = Venus::Collect->new(value => $value);
920  
921 my $execute = $collect->execute(sub{$_});
922  
923 # bless({}, 'Example')
924  
925 =back
926  
927 =over 4
928  
929 =item execute example 39
930  
931 package main;
932  
933 use Venus::Collect;
934  
935 my $value = bless {1..8}, 'Example';
936  
937 my $collect = Venus::Collect->new(value => $value);
938  
939 my $execute = $collect->execute(sub{@_});
940  
941 # bless({1..8}, 'Example')
942  
943 =back
944  
945 =over 4
946  
947 =item execute example 40
948  
949 package main;
950  
951 use Venus::Collect;
952  
953 my $value = bless {1..8}, 'Example';
954  
955 my $collect = Venus::Collect->new(value => $value);
956  
957 my $execute = $collect->execute(sub{$_%6==0 ? (@_) : ()});
958  
959 # bless({5,6}, 'Example')
960  
961 =back
962  
963 =cut
964  
965 =head2 new
966  
967 new(any @args) (Venus::Collect)
968  
969 The new method returns a new instance.
970  
971 I<Since C<4.15>>
972  
973 =over 4
974  
975 =item new example 1
976  
977 package main;
978  
979 use Venus::Collect;
980  
981 my $new = Venus::Collect->new;
982  
983 # bless({value => undef}, 'Venus::Collect')
984  
985 =back
986  
987 =over 4
988  
989 =item new example 2
990  
991 package main;
992  
993 use Venus::Collect;
994  
995 my $new = Venus::Collect->new([1..4]);
996  
997 # bless({value => [1..4]}, 'Venus::Collect')
998  
999 =back
1000  
1001 =over 4
1002  
1003 =item new example 3
1004  
1005 package main;
1006  
1007 use Venus::Collect;
1008  
1009 my $new = Venus::Collect->new(value => [1..4]);
1010  
1011 # bless({value => [1..4]}, 'Venus::Collect')
1012  
1013 =back
1014  
1015 =cut
1016  
1017 =head1 AUTHORS
1018  
1019 Awncorp, C<awncorp@cpan.org>
1020  
1021 =cut
1022  
1023 =head1 LICENSE
1024  
1025 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
1026  
1027 This program is free software, you can redistribute it and/or modify it under
1028 the terms of the Apache license version 2.0.
1029  
1030 =cut
« blib/lib/Venus/Cli.pm ↑ Summary blib/lib/Venus/Set.pm »