File Coverage

blib/lib/Venus/Undef.pm
Criterion Covered Total %
statement 24 28 85.7
branch n/a
condition n/a
subroutine 10 11 90.9
pod 4 6 66.6
total 38 45 84.4


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