How can you write a conditional based on the definedness of multiple variables?
with
, without
, and orwith
are conditionals that work similarly to if
, unless
, and elsif
, except they check for the definedness of their argument instead of their truthiness. Junctions get threaded when used in combination with these, so a conditional like that can be written like this:
my Str $foo = '' if 2.rand.floor;
my Str $bar = '' if 2.rand.floor;
with $foo & $bar {
say 'yes';
} orwith $foo | $bar {
say 'maybe';
} else {
say 'no';
}
Or for an arbitrary number of variables:
my Str @strings = do 2.rand.floor ?? '' !! Nil for ^3;
with all @strings {
say 'yes';
} orwith any @strings {
say 'maybe';
} else {
say 'no';
}
with
et al are great, and I might write a chained with
statement, especially if the matching of particular variable combinations was ad hoc or I thought could become so given expected evolution of the code.
But given your literal question, and the scenario you have in your answer, I'd much more likely go with given
/when
instead:
my ($foo, $bar, $baz) = (Mu, 42).pick xx Inf;
given $foo, $bar, $baz {
when .all.defined { say 'yes' }
when .any.defined { say 'maybe' }
default { say 'no' }
}
You could create a combined value and use a signature as a when
conditional.
( :(…)
is the syntax for a Signature literal. )
given ($foo,$bar,$baz) {
when :( Any:D, Any:D, Any:D ) { 'all defined' }
when :( Any:D, Any:D, Any:U ) { '$baz undefined' }
when :( Any:D, Any:_, Any:D ) { '$bar not checked' }
default { … }
}
You could create lexical constants to make it shorter.
my constant D = Any:D; # defined
my constant U = Any:U; # undefined
my constant _ = Any:_; # either
given ($foo,$bar,$baz) {
when :(D,D,D) { 'all defined' }
when :(D,D,U) { '$baz undefined' }
when :(D,_,D) { '$bar not checked' }
default { … }
}
Or if you want it to be more visual:
my constant term:<▣> = Any:D; # defined
my constant term:<□> = Any:U; # undefined
my constant term:<▨> = Any:_; # either
given ($foo,$bar,$baz) {
when :(▣,▣,▣) { 'all defined' }
when :(▣,▣,□) { '$baz undefined' }
when :(▣,▨,▣) { '$bar not checked' }
default { … }
}
You could create a subroutine that gives the Signature to use instead.
## something like this should work
## but something is weird with the returns constraint
#sub prefix:<d> ( $_ ) {
# my constant %lookup = (
# '▣' => Parameter.new( type => Any:D ),
# '□' => Parameter.new( type => Any:U ),
# '▨' => Parameter.new( type => Any:_ ),
# );
# Signature.new: params => %lookup{.comb}
#}
sub prefix:<d> ( $_ ) {
my constant %lookup = (
'▣' => 'Any:D',
'□' => 'Any:U',
'▨' => 'Any:_',
);
use MONKEY-SEE-NO-EVAL;
EVAL ":(%lookup{.comb}.join(","))"
}
given ($foo,$bar,$baz) {
when d'▣▣▣' { 'all defined' }
when d'▣▣□' { '$baz undefined' }
when d'▣▨▣' { '$bar not checked' }
default { … }
}