blib/lib/Venus/Code.pm

filter: Statementstmt 100% 45 / 45 Branchbran 100% 4 / 4 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 100% 21 / 21 Podpod 100% 8 / 8 totaltotal 100% 78 / 78 CC 3 SCAR 1.6
CC
3
Cov
100%
__ANON__
2.0
__ANON__
2.0
BEGIN
1.0
CRAP 1.2
« blib/lib/Venus/Role/Valuable.pm ↑ Summary blib/lib/Venus/Core/Class.pm »
1 package Venus::Code;
2  
3 11 ▶use 5.018;
Subroutine BEGIN: called CC=1 SCAR=0.0
4  
5 11 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 11 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 # IMPORTS
9  
10 11 ▶use Venus::Class 'base';
Subroutine BEGIN: called CC=1 SCAR=0.0
11  
12 # INHERITS
13  
14 11 base 'Venus::Kind::Value';
15  
16 # OVERLOADS
17  
18 11 ▶use overload (
Subroutine BEGIN: called CC=1 SCAR=0.0
19 2 ▶ '&{}' => sub{$_[0]->value},
Subroutine __ANON__: called CC=1 SCAR=0.0
20 11 fallback => 1,
21 11 );
22  
23 # METHODS
24  
25 4 ▶sub call {
Subroutine call: called CC=1 SCAR=0.0
Pod documented
26 4 my ($self, @args) = @_;
27  
28 4 my $data = $self->get;
29  
30 4 return $data->(@args);
31 }
32  
33 1 ▶sub compose {
Subroutine compose: called CC=1 SCAR=0.0
Pod documented
34 1 my ($self, $code, @args) = @_;
35  
36 1 my $data = $self->get;
37  
38 1 ▶ return sub { (sub { $code->($data->(@_)) })->(@args, @_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
Subroutine __ANON__: called CC=1 SCAR=0.0
39 }
40  
41 1 ▶sub conjoin {
Subroutine conjoin: called CC=1 SCAR=0.0
Pod documented
42 1 my ($self, $code) = @_;
43  
44 1 my $data = $self->get;
45  
46 1 ▶ return sub { $data->(@_) && $code->(@_) };
Subroutine __ANON__: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
&$data(@_) and &$code(@_) 2 3 5
47 }
48  
49 2 ▶sub curry {
Subroutine curry: called CC=1 SCAR=0.0
Pod documented
50 2 my ($self, @args) = @_;
51  
52 2 my $data = $self->get;
53  
54 2 ▶ return sub { $data->(@args, @_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
55 }
56  
57 180 ▶sub default {
Subroutine default: called CC=1 SCAR=0.0
Pod documented
58 180 ▶ return sub{};
Subroutine __ANON__: called CC=1 SCAR=0.0
59 }
60  
61 1 ▶sub disjoin {
Subroutine disjoin: called CC=1 SCAR=0.0
Pod documented
62 1 my ($self, $code) = @_;
63  
64 1 my $data = $self->get;
65  
66 1 ▶ return sub { $data->(@_) || $code->(@_) };
Subroutine __ANON__: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
&$data(@_) or &$code(@_) 2 3 5
67 }
68  
69 1 ▶sub next {
Subroutine next: called CC=1 SCAR=0.0
Pod documented
70 1 my ($self, @args) = @_;
71  
72 1 my $data = $self->get;
73  
74 1 return $data->(@args);
75 }
76  
77 1 ▶sub rcurry {
Subroutine rcurry: called CC=1 SCAR=0.0
Pod documented
78 1 my ($self, @args) = @_;
79  
80 1 my $data = $self->get;
81  
82 1 ▶ return sub { $data->(@_, @args) };
Subroutine __ANON__: called CC=1 SCAR=0.0
83 }
84  
85 11 1;
86  
87  
88  
89 =head1 NAME
90  
91 Venus::Code - Code Class
92  
93 =cut
94  
95 =head1 ABSTRACT
96  
97 Code Class for Perl 5
98  
99 =cut
100  
101 =head1 SYNOPSIS
102  
103 package main;
104  
105 use Venus::Code;
106  
107 my $code = Venus::Code->new(sub {
108 my (@args) = @_;
109  
110 return [@args];
111 });
112  
113 # $code->call(1..4);
114  
115 =cut
116  
117 =head1 DESCRIPTION
118  
119 This package provides methods for manipulating subroutines.
120  
121 =cut
122  
123 =head1 INHERITS
124  
125 This package inherits behaviors from:
126  
127 L<Venus::Kind::Value>
128  
129 =cut
130  
131 =head1 METHODS
132  
133 This package provides the following methods:
134  
135 =cut
136  
137 =head2 call
138  
139 call(any @data) (any)
140  
141 The call method executes and returns the result of the code.
142  
143 I<Since C<0.01>>
144  
145 =over 4
146  
147 =item call example 1
148  
149 package main;
150  
151 use Venus::Code;
152  
153 my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
154  
155 my $call = $code->call;
156  
157 # 1
158  
159 =back
160  
161 =over 4
162  
163 =item call example 2
164  
165 package main;
166  
167 use Venus::Code;
168  
169 my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
170  
171 my $call = $code->call(1);
172  
173 # 2
174  
175 =back
176  
177 =over 4
178  
179 =item call example 3
180  
181 package main;
182  
183 use Venus::Code;
184  
185 my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
186  
187 my $call = $code->call(2);
188  
189 # 3
190  
191 =back
192  
193 =cut
194  
195 =head2 cast
196  
197 cast(string $kind) (object | undef)
198  
199 The cast method converts L<"value"|Venus::Kind::Value> objects between
200 different I<"value"> object types, based on the name of the type provided. This
201 method will return C<undef> if the invocant is not a L<Venus::Kind::Value>.
202  
203 I<Since C<0.08>>
204  
205 =over 4
206  
207 =item cast example 1
208  
209 package main;
210  
211 use Venus::Code;
212  
213 my $code = Venus::Code->new(sub{[@_]});
214  
215 my $cast = $code->cast('array');
216  
217 # bless({ value => [sub { ... }] }, "Venus::Array")
218  
219 =back
220  
221 =over 4
222  
223 =item cast example 2
224  
225 package main;
226  
227 use Venus::Code;
228  
229 my $code = Venus::Code->new;
230  
231 my $cast = $code->cast('boolean');
232  
233 # bless({ value => 1 }, "Venus::Boolean")
234  
235 =back
236  
237 =over 4
238  
239 =item cast example 3
240  
241 package main;
242  
243 use Venus::Code;
244  
245 my $code = Venus::Code->new(sub{[@_]});
246  
247 my $cast = $code->cast('code');
248  
249 # bless({ value => sub { ... } }, "Venus::Code")
250  
251 =back
252  
253 =over 4
254  
255 =item cast example 4
256  
257 package main;
258  
259 use Venus::Code;
260  
261 my $code = Venus::Code->new;
262  
263 my $cast = $code->cast('float');
264  
265 # bless({ value => "1.0" }, "Venus::Float")
266  
267 =back
268  
269 =over 4
270  
271 =item cast example 5
272  
273 package main;
274  
275 use Venus::Code;
276  
277 my $code = Venus::Code->new(sub{[@_]});
278  
279 my $cast = $code->cast('hash');
280  
281 # bless({ value => { "0" => sub { ... } } }, "Venus::Hash")
282  
283 =back
284  
285 =over 4
286  
287 =item cast example 6
288  
289 package main;
290  
291 use Venus::Code;
292  
293 my $code = Venus::Code->new;
294  
295 my $cast = $code->cast('number');
296  
297 # bless({ value => 112 }, "Venus::Number")
298  
299 =back
300  
301 =over 4
302  
303 =item cast example 7
304  
305 package main;
306  
307 use Venus::Code;
308  
309 my $code = Venus::Code->new;
310  
311 my $cast = $code->cast('regexp');
312  
313 # bless({ value => qr/.../, }, "Venus::Regexp")
314  
315 =back
316  
317 =over 4
318  
319 =item cast example 8
320  
321 package main;
322  
323 use Venus::Code;
324  
325 my $code = Venus::Code->new;
326  
327 my $cast = $code->cast('scalar');
328  
329 # bless({ value => \sub {...} }, "Venus::Scalar")
330  
331 =back
332  
333 =over 4
334  
335 =item cast example 9
336  
337 package main;
338  
339 use Venus::Code;
340  
341 my $code = Venus::Code->new;
342  
343 my $cast = $code->cast('string');
344  
345 # bless({ value => "sub {...}" }, "Venus::String")
346  
347 =back
348  
349 =over 4
350  
351 =item cast example 10
352  
353 package main;
354  
355 use Venus::Code;
356  
357 my $code = Venus::Code->new;
358  
359 my $cast = $code->cast('undef');
360  
361 # bless({ value => undef }, "Venus::Undef")
362  
363 =back
364  
365 =cut
366  
367 =head2 compose
368  
369 compose(coderef $code, any @data) (coderef)
370  
371 The compose method creates a code reference which executes the first argument
372 (another code reference) using the result from executing the code as it's
373 argument, and returns a code reference which executes the created code
374 reference passing it the remaining arguments when executed.
375  
376 I<Since C<0.01>>
377  
378 =over 4
379  
380 =item compose example 1
381  
382 package main;
383  
384 use Venus::Code;
385  
386 my $code = Venus::Code->new(sub { [@_] });
387  
388 my $compose = $code->compose($code, 1, 2, 3);
389  
390 # sub { ... }
391  
392 # $compose->(4, 5, 6); # [[1,2,3,4,5,6]]
393  
394 =back
395  
396 =cut
397  
398 =head2 conjoin
399  
400 conjoin(coderef $code) (coderef)
401  
402 The conjoin method creates a code reference which execute the code and the
403 argument in a logical AND operation having the code as the lvalue and the
404 argument as the rvalue.
405  
406 I<Since C<0.01>>
407  
408 =over 4
409  
410 =item conjoin example 1
411  
412 package main;
413  
414 use Venus::Code;
415  
416 my $code = Venus::Code->new(sub { $_[0] % 2 });
417  
418 my $conjoin = $code->conjoin(sub { 1 });
419  
420 # sub { ... }
421  
422 # $conjoin->(0); # 0
423 # $conjoin->(1); # 1
424 # $conjoin->(2); # 0
425 # $conjoin->(3); # 1
426 # $conjoin->(4); # 0
427  
428 =back
429  
430 =cut
431  
432 =head2 curry
433  
434 curry(any @data) (coderef)
435  
436 The curry method returns a code reference which executes the code passing it
437 the arguments and any additional parameters when executed.
438  
439 I<Since C<0.01>>
440  
441 =over 4
442  
443 =item curry example 1
444  
445 package main;
446  
447 use Venus::Code;
448  
449 my $code = Venus::Code->new(sub { [@_] });
450  
451 my $curry = $code->curry(1, 2, 3);
452  
453 # sub { ... }
454  
455 # $curry->(4,5,6); # [1,2,3,4,5,6]
456  
457 =back
458  
459 =cut
460  
461 =head2 default
462  
463 default() (coderef)
464  
465 The default method returns the default value, i.e. C<sub{}>.
466  
467 I<Since C<0.01>>
468  
469 =over 4
470  
471 =item default example 1
472  
473 # given: synopsis;
474  
475 my $default = $code->default;
476  
477 # sub {}
478  
479 =back
480  
481 =cut
482  
483 =head2 disjoin
484  
485 disjoin(coderef $code) (coderef)
486  
487 The disjoin method creates a code reference which execute the code and the
488 argument in a logical OR operation having the code as the lvalue and the
489 argument as the rvalue.
490  
491 I<Since C<0.01>>
492  
493 =over 4
494  
495 =item disjoin example 1
496  
497 package main;
498  
499 use Venus::Code;
500  
501 my $code = Venus::Code->new(sub { $_[0] % 2 });
502  
503 my $disjoin = $code->disjoin(sub { -1 });
504  
505 # sub { ... }
506  
507 # disjoin->(0); # -1
508 # disjoin->(1); # 1
509 # disjoin->(2); # -1
510 # disjoin->(3); # 1
511 # disjoin->(4); # -1
512  
513 =back
514  
515 =cut
516  
517 =head2 eq
518  
519 eq(any $arg) (boolean)
520  
521 The eq method performs an I<"equals"> operation using the argument provided.
522  
523 I<Since C<0.08>>
524  
525 =over 4
526  
527 =item eq example 1
528  
529 package main;
530  
531 use Venus::Array;
532 use Venus::Code;
533  
534 my $lvalue = Venus::Code->new;
535 my $rvalue = Venus::Array->new;
536  
537 my $result = $lvalue->eq($rvalue);
538  
539 # 0
540  
541 =back
542  
543 =over 4
544  
545 =item eq example 2
546  
547 package main;
548  
549 use Venus::Code;
550  
551 my $lvalue = Venus::Code->new;
552 my $rvalue = Venus::Code->new;
553  
554 my $result = $lvalue->eq($rvalue);
555  
556 # 1
557  
558 =back
559  
560 =over 4
561  
562 =item eq example 3
563  
564 package main;
565  
566 use Venus::Code;
567 use Venus::Float;
568  
569 my $lvalue = Venus::Code->new;
570 my $rvalue = Venus::Float->new;
571  
572 my $result = $lvalue->eq($rvalue);
573  
574 # 0
575  
576 =back
577  
578 =over 4
579  
580 =item eq example 4
581  
582 package main;
583  
584 use Venus::Code;
585 use Venus::Hash;
586  
587 my $lvalue = Venus::Code->new;
588 my $rvalue = Venus::Hash->new;
589  
590 my $result = $lvalue->eq($rvalue);
591  
592 # 0
593  
594 =back
595  
596 =over 4
597  
598 =item eq example 5
599  
600 package main;
601  
602 use Venus::Code;
603 use Venus::Number;
604  
605 my $lvalue = Venus::Code->new;
606 my $rvalue = Venus::Number->new;
607  
608 my $result = $lvalue->eq($rvalue);
609  
610 # 0
611  
612 =back
613  
614 =over 4
615  
616 =item eq example 6
617  
618 package main;
619  
620 use Venus::Code;
621 use Venus::Regexp;
622  
623 my $lvalue = Venus::Code->new;
624 my $rvalue = Venus::Regexp->new;
625  
626 my $result = $lvalue->eq($rvalue);
627  
628 # 0
629  
630 =back
631  
632 =over 4
633  
634 =item eq example 7
635  
636 package main;
637  
638 use Venus::Code;
639 use Venus::Scalar;
640  
641 my $lvalue = Venus::Code->new;
642 my $rvalue = Venus::Scalar->new;
643  
644 my $result = $lvalue->eq($rvalue);
645  
646 # 0
647  
648 =back
649  
650 =over 4
651  
652 =item eq example 8
653  
654 package main;
655  
656 use Venus::Code;
657 use Venus::String;
658  
659 my $lvalue = Venus::Code->new;
660 my $rvalue = Venus::String->new;
661  
662 my $result = $lvalue->eq($rvalue);
663  
664 # 0
665  
666 =back
667  
668 =over 4
669  
670 =item eq example 9
671  
672 package main;
673  
674 use Venus::Code;
675 use Venus::Undef;
676  
677 my $lvalue = Venus::Code->new;
678 my $rvalue = Venus::Undef->new;
679  
680 my $result = $lvalue->eq($rvalue);
681  
682 # 0
683  
684 =back
685  
686 =cut
687  
688 =head2 ge
689  
690 ge(any $arg) (boolean)
691  
692 The ge method performs a I<"greater-than-or-equal-to"> operation using the
693 argument provided.
694  
695 I<Since C<0.08>>
696  
697 =over 4
698  
699 =item ge example 1
700  
701 package main;
702  
703 use Venus::Array;
704 use Venus::Code;
705  
706 my $lvalue = Venus::Code->new;
707 my $rvalue = Venus::Array->new;
708  
709 my $result = $lvalue->ge($rvalue);
710  
711 # 1
712  
713 =back
714  
715 =over 4
716  
717 =item ge example 2
718  
719 package main;
720  
721 use Venus::Code;
722  
723 my $lvalue = Venus::Code->new;
724 my $rvalue = Venus::Code->new;
725  
726 my $result = $lvalue->ge($rvalue);
727  
728 # 1
729  
730 =back
731  
732 =over 4
733  
734 =item ge example 3
735  
736 package main;
737  
738 use Venus::Code;
739 use Venus::Float;
740  
741 my $lvalue = Venus::Code->new;
742 my $rvalue = Venus::Float->new;
743  
744 my $result = $lvalue->ge($rvalue);
745  
746 # 1
747  
748 =back
749  
750 =over 4
751  
752 =item ge example 4
753  
754 package main;
755  
756 use Venus::Code;
757 use Venus::Hash;
758  
759 my $lvalue = Venus::Code->new;
760 my $rvalue = Venus::Hash->new;
761  
762 my $result = $lvalue->ge($rvalue);
763  
764 # 1
765  
766 =back
767  
768 =over 4
769  
770 =item ge example 5
771  
772 package main;
773  
774 use Venus::Code;
775 use Venus::Number;
776  
777 my $lvalue = Venus::Code->new;
778 my $rvalue = Venus::Number->new;
779  
780 my $result = $lvalue->ge($rvalue);
781  
782 # 1
783  
784 =back
785  
786 =over 4
787  
788 =item ge example 6
789  
790 package main;
791  
792 use Venus::Code;
793 use Venus::Regexp;
794  
795 my $lvalue = Venus::Code->new;
796 my $rvalue = Venus::Regexp->new;
797  
798 my $result = $lvalue->ge($rvalue);
799  
800 # 1
801  
802 =back
803  
804 =over 4
805  
806 =item ge example 7
807  
808 package main;
809  
810 use Venus::Code;
811 use Venus::Scalar;
812  
813 my $lvalue = Venus::Code->new;
814 my $rvalue = Venus::Scalar->new;
815  
816 my $result = $lvalue->ge($rvalue);
817  
818 # 1
819  
820 =back
821  
822 =over 4
823  
824 =item ge example 8
825  
826 package main;
827  
828 use Venus::Code;
829 use Venus::String;
830  
831 my $lvalue = Venus::Code->new;
832 my $rvalue = Venus::String->new;
833  
834 my $result = $lvalue->ge($rvalue);
835  
836 # 1
837  
838 =back
839  
840 =over 4
841  
842 =item ge example 9
843  
844 package main;
845  
846 use Venus::Code;
847 use Venus::Undef;
848  
849 my $lvalue = Venus::Code->new;
850 my $rvalue = Venus::Undef->new;
851  
852 my $result = $lvalue->ge($rvalue);
853  
854 # 1
855  
856 =back
857  
858 =cut
859  
860 =head2 gele
861  
862 gele(any $arg1, any $arg2) (boolean)
863  
864 The gele method performs a I<"greater-than-or-equal-to"> operation on the 1st
865 argument, and I<"lesser-than-or-equal-to"> operation on the 2nd argument.
866  
867 I<Since C<0.08>>
868  
869 =over 4
870  
871 =item gele example 1
872  
873 package main;
874  
875 use Venus::Array;
876 use Venus::Code;
877  
878 my $lvalue = Venus::Code->new;
879 my $rvalue = Venus::Array->new;
880  
881 my $result = $lvalue->gele($rvalue);
882  
883 # 0
884  
885 =back
886  
887 =over 4
888  
889 =item gele example 2
890  
891 package main;
892  
893 use Venus::Code;
894  
895 my $lvalue = Venus::Code->new;
896 my $rvalue = Venus::Code->new;
897  
898 my $result = $lvalue->gele($rvalue);
899  
900 # 0
901  
902 =back
903  
904 =over 4
905  
906 =item gele example 3
907  
908 package main;
909  
910 use Venus::Code;
911 use Venus::Float;
912  
913 my $lvalue = Venus::Code->new;
914 my $rvalue = Venus::Float->new;
915  
916 my $result = $lvalue->gele($rvalue);
917  
918 # 0
919  
920 =back
921  
922 =over 4
923  
924 =item gele example 4
925  
926 package main;
927  
928 use Venus::Code;
929 use Venus::Hash;
930  
931 my $lvalue = Venus::Code->new;
932 my $rvalue = Venus::Hash->new;
933  
934 my $result = $lvalue->gele($rvalue);
935  
936 # 0
937  
938 =back
939  
940 =over 4
941  
942 =item gele example 5
943  
944 package main;
945  
946 use Venus::Code;
947 use Venus::Number;
948  
949 my $lvalue = Venus::Code->new;
950 my $rvalue = Venus::Number->new;
951  
952 my $result = $lvalue->gele($rvalue);
953  
954 # 0
955  
956 =back
957  
958 =over 4
959  
960 =item gele example 6
961  
962 package main;
963  
964 use Venus::Code;
965 use Venus::Regexp;
966  
967 my $lvalue = Venus::Code->new;
968 my $rvalue = Venus::Regexp->new;
969  
970 my $result = $lvalue->gele($rvalue);
971  
972 # 0
973  
974 =back
975  
976 =over 4
977  
978 =item gele example 7
979  
980 package main;
981  
982 use Venus::Code;
983 use Venus::Scalar;
984  
985 my $lvalue = Venus::Code->new;
986 my $rvalue = Venus::Scalar->new;
987  
988 my $result = $lvalue->gele($rvalue);
989  
990 # 0
991  
992 =back
993  
994 =over 4
995  
996 =item gele example 8
997  
998 package main;
999  
1000 use Venus::Code;
1001 use Venus::String;
1002  
1003 my $lvalue = Venus::Code->new;
1004 my $rvalue = Venus::String->new;
1005  
1006 my $result = $lvalue->gele($rvalue);
1007  
1008 # 0
1009  
1010 =back
1011  
1012 =over 4
1013  
1014 =item gele example 9
1015  
1016 package main;
1017  
1018 use Venus::Code;
1019 use Venus::Undef;
1020  
1021 my $lvalue = Venus::Code->new;
1022 my $rvalue = Venus::Undef->new;
1023  
1024 my $result = $lvalue->gele($rvalue);
1025  
1026 # 0
1027  
1028 =back
1029  
1030 =cut
1031  
1032 =head2 gt
1033  
1034 gt(any $arg) (boolean)
1035  
1036 The gt method performs a I<"greater-than"> operation using the argument provided.
1037  
1038 I<Since C<0.08>>
1039  
1040 =over 4
1041  
1042 =item gt example 1
1043  
1044 package main;
1045  
1046 use Venus::Array;
1047 use Venus::Code;
1048  
1049 my $lvalue = Venus::Code->new;
1050 my $rvalue = Venus::Array->new;
1051  
1052 my $result = $lvalue->gt($rvalue);
1053  
1054 # 1
1055  
1056 =back
1057  
1058 =over 4
1059  
1060 =item gt example 2
1061  
1062 package main;
1063  
1064 use Venus::Code;
1065  
1066 my $lvalue = Venus::Code->new;
1067 my $rvalue = Venus::Code->new;
1068  
1069 my $result = $lvalue->gt($rvalue);
1070  
1071 # 0
1072  
1073 =back
1074  
1075 =over 4
1076  
1077 =item gt example 3
1078  
1079 package main;
1080  
1081 use Venus::Code;
1082 use Venus::Float;
1083  
1084 my $lvalue = Venus::Code->new;
1085 my $rvalue = Venus::Float->new;
1086  
1087 my $result = $lvalue->gt($rvalue);
1088  
1089 # 1
1090  
1091 =back
1092  
1093 =over 4
1094  
1095 =item gt example 4
1096  
1097 package main;
1098  
1099 use Venus::Code;
1100 use Venus::Hash;
1101  
1102 my $lvalue = Venus::Code->new;
1103 my $rvalue = Venus::Hash->new;
1104  
1105 my $result = $lvalue->gt($rvalue);
1106  
1107 # 1
1108  
1109 =back
1110  
1111 =over 4
1112  
1113 =item gt example 5
1114  
1115 package main;
1116  
1117 use Venus::Code;
1118 use Venus::Number;
1119  
1120 my $lvalue = Venus::Code->new;
1121 my $rvalue = Venus::Number->new;
1122  
1123 my $result = $lvalue->gt($rvalue);
1124  
1125 # 1
1126  
1127 =back
1128  
1129 =over 4
1130  
1131 =item gt example 6
1132  
1133 package main;
1134  
1135 use Venus::Code;
1136 use Venus::Regexp;
1137  
1138 my $lvalue = Venus::Code->new;
1139 my $rvalue = Venus::Regexp->new;
1140  
1141 my $result = $lvalue->gt($rvalue);
1142  
1143 # 1
1144  
1145 =back
1146  
1147 =over 4
1148  
1149 =item gt example 7
1150  
1151 package main;
1152  
1153 use Venus::Code;
1154 use Venus::Scalar;
1155  
1156 my $lvalue = Venus::Code->new;
1157 my $rvalue = Venus::Scalar->new;
1158  
1159 my $result = $lvalue->gt($rvalue);
1160  
1161 # 1
1162  
1163 =back
1164  
1165 =over 4
1166  
1167 =item gt example 8
1168  
1169 package main;
1170  
1171 use Venus::Code;
1172 use Venus::String;
1173  
1174 my $lvalue = Venus::Code->new;
1175 my $rvalue = Venus::String->new;
1176  
1177 my $result = $lvalue->gt($rvalue);
1178  
1179 # 1
1180  
1181 =back
1182  
1183 =over 4
1184  
1185 =item gt example 9
1186  
1187 package main;
1188  
1189 use Venus::Code;
1190 use Venus::Undef;
1191  
1192 my $lvalue = Venus::Code->new;
1193 my $rvalue = Venus::Undef->new;
1194  
1195 my $result = $lvalue->gt($rvalue);
1196  
1197 # 1
1198  
1199 =back
1200  
1201 =cut
1202  
1203 =head2 gtlt
1204  
1205 gtlt(any $arg1, any $arg2) (boolean)
1206  
1207 The gtlt method performs a I<"greater-than"> operation on the 1st argument, and
1208 I<"lesser-than"> operation on the 2nd argument.
1209  
1210 I<Since C<0.08>>
1211  
1212 =over 4
1213  
1214 =item gtlt example 1
1215  
1216 package main;
1217  
1218 use Venus::Array;
1219 use Venus::Code;
1220  
1221 my $lvalue = Venus::Code->new;
1222 my $rvalue = Venus::Array->new;
1223  
1224 my $result = $lvalue->gtlt($rvalue);
1225  
1226 # 0
1227  
1228 =back
1229  
1230 =over 4
1231  
1232 =item gtlt example 2
1233  
1234 package main;
1235  
1236 use Venus::Code;
1237  
1238 my $lvalue = Venus::Code->new;
1239 my $rvalue = Venus::Code->new;
1240  
1241 my $result = $lvalue->gtlt($rvalue);
1242  
1243 # 0
1244  
1245 =back
1246  
1247 =over 4
1248  
1249 =item gtlt example 3
1250  
1251 package main;
1252  
1253 use Venus::Code;
1254 use Venus::Float;
1255  
1256 my $lvalue = Venus::Code->new;
1257 my $rvalue = Venus::Float->new;
1258  
1259 my $result = $lvalue->gtlt($rvalue);
1260  
1261 # 0
1262  
1263 =back
1264  
1265 =over 4
1266  
1267 =item gtlt example 4
1268  
1269 package main;
1270  
1271 use Venus::Code;
1272 use Venus::Hash;
1273  
1274 my $lvalue = Venus::Code->new;
1275 my $rvalue = Venus::Hash->new;
1276  
1277 my $result = $lvalue->gtlt($rvalue);
1278  
1279 # 0
1280  
1281 =back
1282  
1283 =over 4
1284  
1285 =item gtlt example 5
1286  
1287 package main;
1288  
1289 use Venus::Code;
1290 use Venus::Number;
1291  
1292 my $lvalue = Venus::Code->new;
1293 my $rvalue = Venus::Number->new;
1294  
1295 my $result = $lvalue->gtlt($rvalue);
1296  
1297 # 0
1298  
1299 =back
1300  
1301 =over 4
1302  
1303 =item gtlt example 6
1304  
1305 package main;
1306  
1307 use Venus::Code;
1308 use Venus::Regexp;
1309  
1310 my $lvalue = Venus::Code->new;
1311 my $rvalue = Venus::Regexp->new;
1312  
1313 my $result = $lvalue->gtlt($rvalue);
1314  
1315 # 0
1316  
1317 =back
1318  
1319 =over 4
1320  
1321 =item gtlt example 7
1322  
1323 package main;
1324  
1325 use Venus::Code;
1326 use Venus::Scalar;
1327  
1328 my $lvalue = Venus::Code->new;
1329 my $rvalue = Venus::Scalar->new;
1330  
1331 my $result = $lvalue->gtlt($rvalue);
1332  
1333 # 0
1334  
1335 =back
1336  
1337 =over 4
1338  
1339 =item gtlt example 8
1340  
1341 package main;
1342  
1343 use Venus::Code;
1344 use Venus::String;
1345  
1346 my $lvalue = Venus::Code->new;
1347 my $rvalue = Venus::String->new;
1348  
1349 my $result = $lvalue->gtlt($rvalue);
1350  
1351 # 0
1352  
1353 =back
1354  
1355 =over 4
1356  
1357 =item gtlt example 9
1358  
1359 package main;
1360  
1361 use Venus::Code;
1362 use Venus::Undef;
1363  
1364 my $lvalue = Venus::Code->new;
1365 my $rvalue = Venus::Undef->new;
1366  
1367 my $result = $lvalue->gtlt($rvalue);
1368  
1369 # 0
1370  
1371 =back
1372  
1373 =cut
1374  
1375 =head2 le
1376  
1377 le(any $arg) (boolean)
1378  
1379 The le method performs a I<"lesser-than-or-equal-to"> operation using the
1380 argument provided.
1381  
1382 I<Since C<0.08>>
1383  
1384 =over 4
1385  
1386 =item le example 1
1387  
1388 package main;
1389  
1390 use Venus::Array;
1391 use Venus::Code;
1392  
1393 my $lvalue = Venus::Code->new;
1394 my $rvalue = Venus::Array->new;
1395  
1396 my $result = $lvalue->le($rvalue);
1397  
1398 # 0
1399  
1400 =back
1401  
1402 =over 4
1403  
1404 =item le example 2
1405  
1406 package main;
1407  
1408 use Venus::Code;
1409  
1410 my $lvalue = Venus::Code->new;
1411 my $rvalue = Venus::Code->new;
1412  
1413 my $result = $lvalue->le($rvalue);
1414  
1415 # 1
1416  
1417 =back
1418  
1419 =over 4
1420  
1421 =item le example 3
1422  
1423 package main;
1424  
1425 use Venus::Code;
1426 use Venus::Float;
1427  
1428 my $lvalue = Venus::Code->new;
1429 my $rvalue = Venus::Float->new;
1430  
1431 my $result = $lvalue->le($rvalue);
1432  
1433 # 0
1434  
1435 =back
1436  
1437 =over 4
1438  
1439 =item le example 4
1440  
1441 package main;
1442  
1443 use Venus::Code;
1444 use Venus::Hash;
1445  
1446 my $lvalue = Venus::Code->new;
1447 my $rvalue = Venus::Hash->new;
1448  
1449 my $result = $lvalue->le($rvalue);
1450  
1451 # 0
1452  
1453 =back
1454  
1455 =over 4
1456  
1457 =item le example 5
1458  
1459 package main;
1460  
1461 use Venus::Code;
1462 use Venus::Number;
1463  
1464 my $lvalue = Venus::Code->new;
1465 my $rvalue = Venus::Number->new;
1466  
1467 my $result = $lvalue->le($rvalue);
1468  
1469 # 0
1470  
1471 =back
1472  
1473 =over 4
1474  
1475 =item le example 6
1476  
1477 package main;
1478  
1479 use Venus::Code;
1480 use Venus::Regexp;
1481  
1482 my $lvalue = Venus::Code->new;
1483 my $rvalue = Venus::Regexp->new;
1484  
1485 my $result = $lvalue->le($rvalue);
1486  
1487 # 0
1488  
1489 =back
1490  
1491 =over 4
1492  
1493 =item le example 7
1494  
1495 package main;
1496  
1497 use Venus::Code;
1498 use Venus::Scalar;
1499  
1500 my $lvalue = Venus::Code->new;
1501 my $rvalue = Venus::Scalar->new;
1502  
1503 my $result = $lvalue->le($rvalue);
1504  
1505 # 0
1506  
1507 =back
1508  
1509 =over 4
1510  
1511 =item le example 8
1512  
1513 package main;
1514  
1515 use Venus::Code;
1516 use Venus::String;
1517  
1518 my $lvalue = Venus::Code->new;
1519 my $rvalue = Venus::String->new;
1520  
1521 my $result = $lvalue->le($rvalue);
1522  
1523 # 0
1524  
1525 =back
1526  
1527 =over 4
1528  
1529 =item le example 9
1530  
1531 package main;
1532  
1533 use Venus::Code;
1534 use Venus::Undef;
1535  
1536 my $lvalue = Venus::Code->new;
1537 my $rvalue = Venus::Undef->new;
1538  
1539 my $result = $lvalue->le($rvalue);
1540  
1541 # 0
1542  
1543 =back
1544  
1545 =cut
1546  
1547 =head2 lt
1548  
1549 lt(any $arg) (boolean)
1550  
1551 The lt method performs a I<"lesser-than"> operation using the argument provided.
1552  
1553 I<Since C<0.08>>
1554  
1555 =over 4
1556  
1557 =item lt example 1
1558  
1559 package main;
1560  
1561 use Venus::Array;
1562 use Venus::Code;
1563  
1564 my $lvalue = Venus::Code->new;
1565 my $rvalue = Venus::Array->new;
1566  
1567 my $result = $lvalue->lt($rvalue);
1568  
1569 # 0
1570  
1571 =back
1572  
1573 =over 4
1574  
1575 =item lt example 2
1576  
1577 package main;
1578  
1579 use Venus::Code;
1580  
1581 my $lvalue = Venus::Code->new;
1582 my $rvalue = Venus::Code->new;
1583  
1584 my $result = $lvalue->lt($rvalue);
1585  
1586 # 0
1587  
1588 =back
1589  
1590 =over 4
1591  
1592 =item lt example 3
1593  
1594 package main;
1595  
1596 use Venus::Code;
1597 use Venus::Float;
1598  
1599 my $lvalue = Venus::Code->new;
1600 my $rvalue = Venus::Float->new;
1601  
1602 my $result = $lvalue->lt($rvalue);
1603  
1604 # 0
1605  
1606 =back
1607  
1608 =over 4
1609  
1610 =item lt example 4
1611  
1612 package main;
1613  
1614 use Venus::Code;
1615 use Venus::Hash;
1616  
1617 my $lvalue = Venus::Code->new;
1618 my $rvalue = Venus::Hash->new;
1619  
1620 my $result = $lvalue->lt($rvalue);
1621  
1622 # 0
1623  
1624 =back
1625  
1626 =over 4
1627  
1628 =item lt example 5
1629  
1630 package main;
1631  
1632 use Venus::Code;
1633 use Venus::Number;
1634  
1635 my $lvalue = Venus::Code->new;
1636 my $rvalue = Venus::Number->new;
1637  
1638 my $result = $lvalue->lt($rvalue);
1639  
1640 # 0
1641  
1642 =back
1643  
1644 =over 4
1645  
1646 =item lt example 6
1647  
1648 package main;
1649  
1650 use Venus::Code;
1651 use Venus::Regexp;
1652  
1653 my $lvalue = Venus::Code->new;
1654 my $rvalue = Venus::Regexp->new;
1655  
1656 my $result = $lvalue->lt($rvalue);
1657  
1658 # 0
1659  
1660 =back
1661  
1662 =over 4
1663  
1664 =item lt example 7
1665  
1666 package main;
1667  
1668 use Venus::Code;
1669 use Venus::Scalar;
1670  
1671 my $lvalue = Venus::Code->new;
1672 my $rvalue = Venus::Scalar->new;
1673  
1674 my $result = $lvalue->lt($rvalue);
1675  
1676 # 0
1677  
1678 =back
1679  
1680 =over 4
1681  
1682 =item lt example 8
1683  
1684 package main;
1685  
1686 use Venus::Code;
1687 use Venus::String;
1688  
1689 my $lvalue = Venus::Code->new;
1690 my $rvalue = Venus::String->new;
1691  
1692 my $result = $lvalue->lt($rvalue);
1693  
1694 # 0
1695  
1696 =back
1697  
1698 =over 4
1699  
1700 =item lt example 9
1701  
1702 package main;
1703  
1704 use Venus::Code;
1705 use Venus::Undef;
1706  
1707 my $lvalue = Venus::Code->new;
1708 my $rvalue = Venus::Undef->new;
1709  
1710 my $result = $lvalue->lt($rvalue);
1711  
1712 # 0
1713  
1714 =back
1715  
1716 =cut
1717  
1718 =head2 ne
1719  
1720 ne(any $arg) (boolean)
1721  
1722 The ne method performs a I<"not-equal-to"> operation using the argument provided.
1723  
1724 I<Since C<0.08>>
1725  
1726 =over 4
1727  
1728 =item ne example 1
1729  
1730 package main;
1731  
1732 use Venus::Array;
1733 use Venus::Code;
1734  
1735 my $lvalue = Venus::Code->new;
1736 my $rvalue = Venus::Array->new;
1737  
1738 my $result = $lvalue->ne($rvalue);
1739  
1740 # 1
1741  
1742 =back
1743  
1744 =over 4
1745  
1746 =item ne example 2
1747  
1748 package main;
1749  
1750 use Venus::Code;
1751  
1752 my $lvalue = Venus::Code->new;
1753 my $rvalue = Venus::Code->new;
1754  
1755 my $result = $lvalue->ne($rvalue);
1756  
1757 # 0
1758  
1759 =back
1760  
1761 =over 4
1762  
1763 =item ne example 3
1764  
1765 package main;
1766  
1767 use Venus::Code;
1768 use Venus::Float;
1769  
1770 my $lvalue = Venus::Code->new;
1771 my $rvalue = Venus::Float->new;
1772  
1773 my $result = $lvalue->ne($rvalue);
1774  
1775 # 1
1776  
1777 =back
1778  
1779 =over 4
1780  
1781 =item ne example 4
1782  
1783 package main;
1784  
1785 use Venus::Code;
1786 use Venus::Hash;
1787  
1788 my $lvalue = Venus::Code->new;
1789 my $rvalue = Venus::Hash->new;
1790  
1791 my $result = $lvalue->ne($rvalue);
1792  
1793 # 1
1794  
1795 =back
1796  
1797 =over 4
1798  
1799 =item ne example 5
1800  
1801 package main;
1802  
1803 use Venus::Code;
1804 use Venus::Number;
1805  
1806 my $lvalue = Venus::Code->new;
1807 my $rvalue = Venus::Number->new;
1808  
1809 my $result = $lvalue->ne($rvalue);
1810  
1811 # 1
1812  
1813 =back
1814  
1815 =over 4
1816  
1817 =item ne example 6
1818  
1819 package main;
1820  
1821 use Venus::Code;
1822 use Venus::Regexp;
1823  
1824 my $lvalue = Venus::Code->new;
1825 my $rvalue = Venus::Regexp->new;
1826  
1827 my $result = $lvalue->ne($rvalue);
1828  
1829 # 1
1830  
1831 =back
1832  
1833 =over 4
1834  
1835 =item ne example 7
1836  
1837 package main;
1838  
1839 use Venus::Code;
1840 use Venus::Scalar;
1841  
1842 my $lvalue = Venus::Code->new;
1843 my $rvalue = Venus::Scalar->new;
1844  
1845 my $result = $lvalue->ne($rvalue);
1846  
1847 # 1
1848  
1849 =back
1850  
1851 =over 4
1852  
1853 =item ne example 8
1854  
1855 package main;
1856  
1857 use Venus::Code;
1858 use Venus::String;
1859  
1860 my $lvalue = Venus::Code->new;
1861 my $rvalue = Venus::String->new;
1862  
1863 my $result = $lvalue->ne($rvalue);
1864  
1865 # 1
1866  
1867 =back
1868  
1869 =over 4
1870  
1871 =item ne example 9
1872  
1873 package main;
1874  
1875 use Venus::Code;
1876 use Venus::Undef;
1877  
1878 my $lvalue = Venus::Code->new;
1879 my $rvalue = Venus::Undef->new;
1880  
1881 my $result = $lvalue->ne($rvalue);
1882  
1883 # 1
1884  
1885 =back
1886  
1887 =cut
1888  
1889 =head2 new
1890  
1891 new(any @args) (Venus::Code)
1892  
1893 The new method constructs an instance of the package.
1894  
1895 I<Since C<4.15>>
1896  
1897 =over 4
1898  
1899 =item new example 1
1900  
1901 package main;
1902  
1903 use Venus::Code;
1904  
1905 my $new = Venus::Code->new;
1906  
1907 # bless(..., "Venus::Code")
1908  
1909 =back
1910  
1911 =over 4
1912  
1913 =item new example 2
1914  
1915 package main;
1916  
1917 use Venus::Code;
1918  
1919 my $new = Venus::Code->new(sub{});
1920  
1921 # bless(..., "Venus::Code")
1922  
1923 =back
1924  
1925 =over 4
1926  
1927 =item new example 3
1928  
1929 package main;
1930  
1931 use Venus::Code;
1932  
1933 my $new = Venus::Code->new(value => sub{});
1934  
1935 # bless(..., "Venus::Code")
1936  
1937 =back
1938  
1939 =cut
1940  
1941 =head2 next
1942  
1943 next(any @data) (any)
1944  
1945 The next method is an alias to the call method. The naming is especially useful
1946 (i.e. helps with readability) when used with closure-based iterators.
1947  
1948 I<Since C<0.01>>
1949  
1950 =over 4
1951  
1952 =item next example 1
1953  
1954 package main;
1955  
1956 use Venus::Code;
1957  
1958 my $code = Venus::Code->new(sub { $_[0] * 2 });
1959  
1960 my $next = $code->next(72);
1961  
1962 # 144
1963  
1964 =back
1965  
1966 =cut
1967  
1968 =head2 rcurry
1969  
1970 rcurry(any @data) (coderef)
1971  
1972 The rcurry method returns a code reference which executes the code passing it
1973 the any additional parameters and any arguments when executed.
1974  
1975 I<Since C<0.01>>
1976  
1977 =over 4
1978  
1979 =item rcurry example 1
1980  
1981 package main;
1982  
1983 use Venus::Code;
1984  
1985 my $code = Venus::Code->new(sub { [@_] });
1986  
1987 my $rcurry = $code->rcurry(1,2,3);
1988  
1989 # sub { ... }
1990  
1991 # $rcurry->(4,5,6); # [4,5,6,1,2,3]
1992  
1993 =back
1994  
1995 =cut
1996  
1997 =head2 tv
1998  
1999 tv(any $arg) (boolean)
2000  
2001 The tv method performs a I<"type-and-value-equal-to"> operation using argument
2002 provided.
2003  
2004 I<Since C<0.08>>
2005  
2006 =over 4
2007  
2008 =item tv example 1
2009  
2010 package main;
2011  
2012 use Venus::Array;
2013 use Venus::Code;
2014  
2015 my $lvalue = Venus::Code->new;
2016 my $rvalue = Venus::Array->new;
2017  
2018 my $result = $lvalue->tv($rvalue);
2019  
2020 # 0
2021  
2022 =back
2023  
2024 =over 4
2025  
2026 =item tv example 2
2027  
2028 package main;
2029  
2030 use Venus::Code;
2031  
2032 my $lvalue = Venus::Code->new;
2033 my $rvalue = Venus::Code->new;
2034  
2035 my $result = $lvalue->tv($rvalue);
2036  
2037 # 1
2038  
2039 =back
2040  
2041 =over 4
2042  
2043 =item tv example 3
2044  
2045 package main;
2046  
2047 use Venus::Code;
2048 use Venus::Float;
2049  
2050 my $lvalue = Venus::Code->new;
2051 my $rvalue = Venus::Float->new;
2052  
2053 my $result = $lvalue->tv($rvalue);
2054  
2055 # 0
2056  
2057 =back
2058  
2059 =over 4
2060  
2061 =item tv example 4
2062  
2063 package main;
2064  
2065 use Venus::Code;
2066 use Venus::Hash;
2067  
2068 my $lvalue = Venus::Code->new;
2069 my $rvalue = Venus::Hash->new;
2070  
2071 my $result = $lvalue->tv($rvalue);
2072  
2073 # 0
2074  
2075 =back
2076  
2077 =over 4
2078  
2079 =item tv example 5
2080  
2081 package main;
2082  
2083 use Venus::Code;
2084 use Venus::Number;
2085  
2086 my $lvalue = Venus::Code->new;
2087 my $rvalue = Venus::Number->new;
2088  
2089 my $result = $lvalue->tv($rvalue);
2090  
2091 # 0
2092  
2093 =back
2094  
2095 =over 4
2096  
2097 =item tv example 6
2098  
2099 package main;
2100  
2101 use Venus::Code;
2102 use Venus::Regexp;
2103  
2104 my $lvalue = Venus::Code->new;
2105 my $rvalue = Venus::Regexp->new;
2106  
2107 my $result = $lvalue->tv($rvalue);
2108  
2109 # 0
2110  
2111 =back
2112  
2113 =over 4
2114  
2115 =item tv example 7
2116  
2117 package main;
2118  
2119 use Venus::Code;
2120 use Venus::Scalar;
2121  
2122 my $lvalue = Venus::Code->new;
2123 my $rvalue = Venus::Scalar->new;
2124  
2125 my $result = $lvalue->tv($rvalue);
2126  
2127 # 0
2128  
2129 =back
2130  
2131 =over 4
2132  
2133 =item tv example 8
2134  
2135 package main;
2136  
2137 use Venus::Code;
2138 use Venus::String;
2139  
2140 my $lvalue = Venus::Code->new;
2141 my $rvalue = Venus::String->new;
2142  
2143 my $result = $lvalue->tv($rvalue);
2144  
2145 # 0
2146  
2147 =back
2148  
2149 =over 4
2150  
2151 =item tv example 9
2152  
2153 package main;
2154  
2155 use Venus::Code;
2156 use Venus::Undef;
2157  
2158 my $lvalue = Venus::Code->new;
2159 my $rvalue = Venus::Undef->new;
2160  
2161 my $result = $lvalue->tv($rvalue);
2162  
2163 # 0
2164  
2165 =back
2166  
2167 =cut
2168  
2169 =head1 OPERATORS
2170  
2171 This package overloads the following operators:
2172  
2173 =cut
2174  
2175 =over 4
2176  
2177 =item operation: C<(&{})>
2178  
2179 This package overloads the C<&{}> operator.
2180  
2181 B<example 1>
2182  
2183 # given: synopsis;
2184  
2185 my $result = &$code(1..4);
2186  
2187 # [1..4]
2188  
2189 =back
2190  
2191 =head1 AUTHORS
2192  
2193 Awncorp, C<awncorp@cpan.org>
2194  
2195 =cut
2196  
2197 =head1 LICENSE
2198  
2199 Copyright (C) 2022, Awncorp, C<awncorp@cpan.org>.
2200  
2201 This program is free software, you can redistribute it and/or modify it under
2202 the terms of the Apache license version 2.0.
2203  
2204 =cut
« blib/lib/Venus/Role/Valuable.pm ↑ Summary blib/lib/Venus/Core/Class.pm »