blib/lib/Venus/Scalar.pm

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