blib/lib/Venus/Boolean.pm

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