enum Bool <False True>

An enum for Boolean true/false decisions.


method ACCEPTS§

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

Used for smartmatch comparison. When the right side is True returns always True, when the right side of the match is False returns always False. In particular, ACCEPTS returns always the instance on which it is invoked, that is the right side of a smartmatch. As an example:

my $b = Bool.newTrue );
# when True on the right side returns 
# always True 
True  ~~ $b;     # True 
False ~~ $b;     # True 
$b = Bool.newFalse );
# when False on the right side 
# returns always False 
False ~~ $b;     # False 
True ~~ $b;      # False 

routine succ§

method succ(--> Bool:D)

Returns True.

say True.succ;                                    # OUTPUT: «True␤» 
say False.succ;                                   # OUTPUT: «True␤»

succ is short for "successor"; it returns the next enum value. Bool is a special enum with only two values, False and True. When sorted, False comes first, so True is its successor. And since True is the "highest" Bool enum value, its own successor is also True.

routine pred§

method pred(--> Bool:D)

Returns False.

say True.pred;                                    # OUTPUT: «False␤» 
say False.pred;                                   # OUTPUT: «False␤»

pred is short for "predecessor"; it returns the previous enum value. Bool is a special enum with only two values, False and True. When sorted, False comes first, so False is the predecessor to True. And since False is the "lowest" Bool enum value, its own predecessor is also False.

routine enums§

method enums(--> Hash:D)

Returns a Hash of enum-pairs. Works on both the Bool type and any key.

say Bool.enums;                                   # OUTPUT: «{False => 0, True => 1}␤» 
say False.enums;                                  # OUTPUT: «{False => 0, True => 1}␤»

routine pick§

multi method pick(Bool:U: --> Bool:D)
multi method pick(Bool:U: $count --> Seq:D)

Returns a random pick of True and/or False.

If it's called without an argument then it returns just one pick:

say Bool.pick;                                    # OUTPUT: «True␤»

If it's called with a $count of one then it returns a Seq with just one pick:

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

If $count is * or greater than or equal to two then it returns a Seq with two elements -- either True then False, or False then True:

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

routine roll§

multi method roll(Bool:U --> Bool:D)
multi method roll(Bool:U $count --> Seq:D)

Returns True or False if called without any argument. Otherwise returns $count elements chosen at random. Note that each random choice from the enum is made independently, like a separate coin toss where each side of the coin represents one of the two values of the enum. If * is passed as $count an infinite Seq of Bools is returned.

say Bool.roll;                                    # OUTPUT: «True␤» 
say Bool.roll(3);                                 # OUTPUT: «(True False False)␤» 
say Bool.roll(*);                                 # OUTPUT: «(...)␤»

routine Int§

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

Returns the value part of the enum pair.

say False.Int;                                # OUTPUT: «0␤» 
say True.Int;                                 # OUTPUT: «1␤»

routine Numeric§

multi method Numeric(Bool:D --> Int:D)

Returns the value part of the enum pair.

say False.Numeric;                                # OUTPUT: «0␤» 
say True.Numeric;                                 # OUTPUT: «1␤»


prefix ?§

multi sub prefix:<?>(Mu --> Bool:D)

Coerces its argument to Bool.

prefix so§

multi sub prefix:<so>(Mu --> Bool:D)

Coerces its argument to Bool, has looser precedence than prefix:<?>.


Type relations for Bool
raku-type-graph Bool Bool Int Int Bool->Int Mu Mu Any Any Any->Mu Cool Cool Cool->Any Numeric Numeric Real Real Real->Numeric Int->Cool Int->Real

Expand chart above