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]