In attempting to formulate another reply to
this little game of golf, I've hit upon some rather peculiar behaviour in list expression evaluation order. Consider the following recursive code:
sub li {
shift;
@_ ? (scalar @_, &li) : ();
}
print li qw(a b c d e f g); # prints 654321
So far so good... now substitute
$#_ + 1 for
scalar @_:
sub li {
shift;
@_ ? ($#_ + 1, &li) : ();
}
print li qw(a b c d e f g); # prints 654321
Que bueno! Moving on, lets remove the "+1" ...
sub li {
shift;
@_ ? ($#_, &li) : ();
}
print li qw(a b c d e f g); # prints -1-1-1-1-1-1
What is this? Apparently, $#_ is now evaluated
after the recursive call. To my eyes, this is a rather unexpected result, especially when you consider how the comma operator behaves in a scalar context, and my first two examples. This phenomenon affects globals as well:
use vars '$x';
sub li {
$x = shift;
@_ ? ($x, &li) : ();
}
print li qw(a b c d e f g); # prints gggggg
Update: remarkably, I've just determined that this behaviour is tied to the way in which the subroutine call is performed: if the calls above are switched from
&li to
li(@_), the order of evaluation goes back to normal. How wierd!
Update2: actually, the above only works for the $#_, but not the globals. Stranger and stranger...