More questions regarding the new 'given when' construct.
1) Is a 'when' clause required? Is it:
[ LABEL: ] given ( expr_1 ) {
when expr_2 : block
[ when expr_3 : block ...]
expr_n [;]
}
or
[ LABEL: ] given ( expr_1 ) {
[ when expr_2 : block ...]
expr_n [;]
}
?
2) In expressions 2 through n-1 - the equivalent to 'case' - you may refer
to the return value of expression 1 with $^_. Does this imply that
expression 1 will always (and only) be evaluated in scalar context? If not,
can you mix contexts across 'when' clauses? Is the value of $^_ then a
reference to the return value?
3) Can you refer to $^_ within expression n - the equivalent to 'default:'?
given ( a() ) {
print $^_; # No when clause? See #1
}
4) Can you refer to $^_ within the code blocks of each 'when' clause?
given ( a() ) {
when $^_ == 1 : { foo($^_) }
when $^_ == 2 : { bar( 5 + $^_ ) }
when $^_ == 3 : { ++$^_ and print $^_ } # Mutable? See #5
}
5) Is $^_ an alias, reference (See #2), or a copy of the return value of
expression 1, and is it mutable? Does it have the appropriate magic and
overloading capabilities?
6) How many times is expression 1 evaluated?
$a = 0;
given ( ++$a ) {
when $^_ > 5 : { #foo }
when $^_ > 4 : { #bar }
when $^_ > 3 : { #baz }
#foobar
}
I would expect that $a would equal '1' after #foobar executed. But if
multiple contexts are allowed (see question 2), how would
sub a { # returns something different based on scalar or array context }
given ( a() ) {
when $^_ =~ /foo/ : { #foo in scalar context, with "" overloading? }
when $^_[5] eq "bar" : { #bar in list context (bad variable) }
when $^_ : { #baz in boolean context? }
when $^_ + 5 > 15 : { #foobar in scalar, with addition overloading? }
#default
}
be evaluated? In particular, would the fourth 'when' clause (the second use
of scalar context) use the previously obtained scalar value?
7) The 'when' blocks are not fall-through, a la C's switch statement. You
can obtain a similar result by invoking 'next' within the 'when' block.
given ( $a ) {
when expr1 : { print "*" && next }
when expr2 : { print "*" }
}
Is this regardless of whether expr2 would have also evaluted true? (IOW,
does it truly jump to the next block?) If not, does it jump to the
expression after that (if it exists) and try again, or does it default
expression (since the original next expression evaluated false)?
8) Is the order of evaluation guaranteed? (I assume so, but just thought
I'd check.)
9) It has a lexical construct similar to a conditional block, so that
lexical variables declared in the 'given' expression are within the inner
scope, correct?
$a = 5;
given (my $a = 1) {
when $^_ == 1 : { print $a } # 1
print $a; # 1
}
print $a; # 5
10) I've already asked Damian this question on the side, but I'll repeat
(and expand) it here, to give me an even ten. Should it be a single default
expression, multiple default expressions, or a default block?
[ LABEL: ] given ( expr_1 ) {
...
expr_n [;]
}
[ LABEL: ] given ( expr_1 ) {
...
expr_n
[; expr_n+1 ... ] [;]
}
[ LABEL: ] given ( expr_1 ) {
...
block
}
--
Bryan C. Warnock
[EMAIL PROTECTED]
