Marcel Grünauer

On Twitter, Curtis Poe (@OvidPerl) posted some interesting and unintuitive Perl code; I've slightly reformatted it and changed some values for the sake of the following discussion.

use Data::Dumper;
sub boo { 4,5,6 }
my @x = ( boo() || 5,8,7);
print Dumper \@x;

What do you think this prints?

Let's look at some simpler examples of code:

$ perl -le'@x = (4,5,6,7,8); $y = @x; print $y'
5

An array like @x, in scalar context, evaluates to the number of elements in that array. In this case, @x contains five elements.

$ perl -le'$y = (4,5,6,7,8); print $y'
8

A list, as opposed to an array, returns the last element in scalar context - in this case, 8.

Let's see how perl parses this line. We can use the B::Deparse module with the -p option, which adds extra parentheses to make the structure clearer.

$ perl -MO=Deparse,-p -le'$y = (4,5,6,7,8); print $y'
BEGIN { $/ = "\n"; $\ = "\n"; }
($y = ('???', '???', '???', '???', 8));
print($y);
-e syntax OK

As you can see, the unused constant values have been optimized away.

perldoc perldata says this about arrays and lists in scalar context:

If you evaluate an array in scalar context, it returns the length of the array. (Note that this is not true of lists, which return the last value, like the C comma operator, nor of built-in functions, which return whatever they feel like returning.)

And finally:

$ perl -le'$y = (4..8); print $y'

This prints an empty line. You might have thought that this is the same as the line with the list above, but the range operator is somewhat different. In list context, it does indeed return a list of values counting from the left value to the right value. However, in scalar context, the range operator behaves like a flip-flop, starting out with a false value, which stringifies to an empty string.

perldoc perlop says this about the range operator:

In scalar context, ".." returns a boolean value. The operator is bistable, like a flip-flop, and emulates the line-range (comma) operator of sed, awk, and various editors. Each ".." operator maintains its own boolean state, even across calls to a subroutine that contains it. It is false as long as its left operand is false. Once the left operand is true, the range operator stays true until the right operand is true, AFTER which the range operator becomes false again.

After this discussion, you probably know what the program at the beginning of this post prints. Let's look at how perl parses it:

$ perl -MO=Deparse,-p test.pl 
use Data::Dumper;
sub boo {
    (4, 5, 6);
}
(my(@x) = ((boo() || 5), 8, 7));
print(Dumper((\@x)));
test.pl syntax OK

If we run the program, it prints:

$ perl test.pl 
$VAR1 = [
          6,
          8,
          7
        ];

The expression (boo() || 5) is the same as ((4, 5, 6) || 5) and since a list returns the last value in scalar context, this is the same as (6 || 5), which is 6.