From type/Promise

See Original text in context

multi method Bool(Promise:D:)

Returns True for a kept or broken promise, and False for one in state Planned.

From type/Baggy

See Original text in context

method Bool(Baggy:D: --> Bool:D)

Returns True if the invocant contains at least one element.

my $breakfast = ('eggs' => 1).BagHash;
say $breakfast.Bool;                              # OUTPUT: «True␤» 
                                                  # (since we have one element) 
$breakfast<eggs> = 0;                             # weight == 0 will lead to element removal 
say $breakfast.Bool;                              # OUTPUT: «False␤»

From type/Rational

See Original text in context

multi method Bool(Rational:D: --> Bool:D)

Returns False if numerator is 0, otherwise returns True. This applies for <0/0> zero-denominator Rational as well, despite ?<0/0>.Num being True.

From type/Blob

See Original text in context

multi method Bool(Blob:D:)

Returns False if and only if the buffer is empty.

my $blob = Blob.new();
say $blob.Bool; # OUTPUT: «False␤» 
$blob = Blob.new([1, 2, 3]);
say $blob.Bool; # OUTPUT: «True␤»

From type/Match

See Original text in context

method Bool(Capture:D: --> Bool:D)

Returns True on successful and False on unsuccessful matches. Please note that any zero-width match can also be successful.

say 'abc' ~~ /^/;                   # OUTPUT: «｢｣␤» 
say $/.from, ' ',  $/.to, ' ', ?$/; # OUTPUT: «0 0 True␤»

From type/Setty

See Original text in context

multi method Bool(Setty:D: --> Bool:D)

Returns True if the invocant contains at least one element.

my $s1 = Set.new(1, 2, 3);
say $s1.Bool;                                     # OUTPUT: «True␤» 
 
my $s2 = $s1 ∩ Set.new(4, 5);                     # set intersection operator 
say $s2.Bool;                                     # OUTPUT: «False␤»

From type/Mu

See Original text in context

multi sub    Bool(Mu --> Bool:D)
multi method Bool(   --> Bool:D)

Returns False on the type object, and True otherwise.

Many built-in types override this to be False for empty collections, the empty string or numerical zeros

say Mu.Bool;                    # OUTPUT: «False␤» 
say Mu.new.Bool;                # OUTPUT: «True␤» 
say [1, 2, 3].Bool;             # OUTPUT: «True␤» 
say [].Bool;                    # OUTPUT: «False␤» 
say %( hash => 'full' ).Bool;   # OUTPUT: «True␤» 
say {}.Bool;                    # OUTPUT: «False␤» 
say "".Bool;                    # OUTPUT: «False␤» 
say 0.Bool;                     # OUTPUT: «False␤» 
say 1.Bool;                     # OUTPUT: «True␤» 
say "0".Bool;                   # OUTPUT: «True␤»

From type/StrDistance

See Original text in context

Returns True if before is different from after.

From type/Numeric

See Original text in context

multi method Bool(Numeric:D:)

Returns False if the number is equivalent to zero, and True otherwise.

From type/Proc

See Original text in context

multi method Bool(Proc:D:)

Awaits for the process to finish and returns True if both exit code and signal of the process were 0, indicating a successful process termination. Returns False otherwise.

From type/Failure

See Original text in context

multi method Bool(Failure:D: --> Bool:D)

Returns False, and marks the failure as handled.

sub f() { fail };
my $v = f;
say $v.handled; # OUTPUT: «False␤» 
say $v.Bool;    # OUTPUT: «False␤» 
say $v.handled; # OUTPUT: «True␤»

From type/Map

See Original text in context

method Bool(Map:D: --> Bool:D)

Returns True if the invocant contains at least one key/value pair.

my $m = Map.new('a' => 2, 'b' => 17);
say $m.Bool;                                      # OUTPUT: «True␤»

From type/Capture

See Original text in context

method Bool(Capture:D: --> Bool:D)

Returns True if the Capture contains at least one named or one positional argument.

say \(1,2,3, apples => 2).Bool; # OUTPUT: «True␤» 
say \().Bool;                   # OUTPUT: «False␤»

From type/Allomorph

See Original text in context

multi method Bool(::?CLASS:D:)

Returns False if the invocant is numerically 0, otherwise returns True. The Str value of the invocant is not considered.

Note: For the Allomorph subclass RatStr also see Rational.Bool.

From type/Regex

See Original text in context

multi method Bool(Regex:D: --> Bool:D)

Matches against the caller's $_ variable, and returns True for a match or False for no match.

From type/Str

See Original text in context

method Bool(Str:D: --> Bool:D)

Returns False if the string is empty, True otherwise.

From type/List

See Original text in context

method Bool(List:D: --> Bool:D)

Returns True if the list has at least one element, and False for the empty list.

say ().Bool;  # OUTPUT: «False␤» 
say (1).Bool; # OUTPUT: «True␤»

From type/Junction

See Original text in context

multi method Bool(Junction:D:)

Collapses the Junction and returns a single Boolean value according to the type and the values it holds. Every element is transformed to Bool.

my $n = Junction.new( "one", 1..6 );
say $n.Bool;                         # OUTPUT: «False␤» 

All elements in this case are converted to True, so it's false to assert that only one of them is.

my $n = Junction.new( "one", <0 1> );
say $n.Bool;                         # OUTPUT: «True␤» 

Just one of them is truish in this case, 1, so the coercion to Bool returns True.