blib/lib/Venus/Undef.pm

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