perl - Is there such a thing as a list in scalar context?

Question

my $mind = ( 'a', 'little', 'confused' );

---

And it's because perldoc perlfaq4 explains the line above as follows (emphasis added):

Since you're assigning to a scalar, the righthand side is in scalar context. The comma operator (yes, it's an operator!) in scalar context evaluates its lefthand side, throws away the result, and evaluates it's righthand side and returns the result. In effect, that list-lookalike assigns to $scalar it's rightmost value. Many people mess this up because they choose a list-lookalike whose last element is also the count they expect:

my $scalar = ( 1, 2, 3 );  # $scalar gets 3, accidentally

What I understand this to mean is that there is no such thing as a list in scalar context.

However, ikegami maintains that it "result[s] in a list operator, so it is a list literal."

So, is it a list or not?

Answer 1

A list literal is something that is actually a list written out in code, so (1, 2, 3) is a list literal, whereas caller for example is a function that could return a list or a scalar depending on context.

In a line like:

my $x = ...;

the ... sees scalar context, so if ... was a list literal, then you would have a list literal in scalar context:

my $x = (1, 2, 3);

but the list literal does not result in a list, because the comma operator it contains sees scalar context, which then results in it returning the last item of the list literal, and throwing the remaining values away after evaluating them.

In terms of a function, the function itself sees whatever context it is called from, which then is propagated to any line in that function that returns. So you can have a function in scalar, list, or void context, and if the last line of that sub happens to be a list literal, that list literal will see any of those contexts and will behave appropriately.

So basically this is a terminology distinction, with list literal referring to a comma separated list of values in the actual source code*, and list referring to a sequence of values placed onto perl's stack.

You can write subroutines with return values that either behave like arrays or like list literals with regard to context.

sub returns_like_array  {my @x = 1..5; return @x}

sub returns_like_list   {my @x = 1..5; return @x[0 .. $#x]}

*or something that results in a list of comma separated values, like a qw() or a fat comma => or a hash or array slice.

You can also look at my answer here: How do I get the first item from a function that returns an array in Perl? which goes into a bit more detail about lists.