File Coverage

blib/lib/Venus/Code.pm
Criterion Covered Total %
statement 43 47 91.4
branch 4 4 100.0
condition n/a
subroutine 20 21 95.2
pod 9 9 100.0
total 76 81 93.8


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