Gunnar Hjalmarsson said:
In that case, how would you describe this statement:
my $scalar = (10, 20, 30);
An obfucated way of saying:
10; 20; my $scalar = 30;
No, seriously, I might describe it as a list but I would know I was
using sloppy terminology in the same way as a might sloppily refer to
an "array of arrays" in Perl when really I mean "array of refernces to
arrays". As I've said numerous times sloppy short-hand terminology is
fine as long as everyone knows that's what it is. Things start to go
wrong as soon as people start trying to draw inferences from a literal
interpretation of the short-hand terminology.
I certainly would not describe the RHS of the above statement as a
LIST (in capitals) because it is not.
I've previously suggested we could introduce the term "lexical list"
to describe a fragment of Perl source code that has a list-like
appearance but is not a LIST. The trouble with this is that people
might confuse people even more.
In perl there are two ways a comma can be parsed. In an argument-list
(of a protyped function) list it can be parsed as an argument
separator.
In other contexts it's an left associative operator.
In a LIST context comma is the LIST concatenation operator. It
evaluates it's LHS and RHS operands in LIST contexts then returns the
concatenation of the LISTs.
In a SCALAR context comma evaluates it's LHS operand in a VOID
context, then evaluates it's RHS operand in a SCALAR context then
returns value of the RHS.
In a VOID context comma evaluates it's LHS operand in a VOID context,
then evaluates it's RHS operand in a VOID context then doesn't return
anything (because it's in a VOID context - like duh!).
Note unlike most operators the order of the evaluation of the operands
by a comma operator in a SCALAR or VOID context is assured.
Technically it's not assured in a LIST context but I suspect that it
would break so much code it it ever changed that it's unlikely ever to
do so.
What's the difference compared to a list literal (besides the warnings)?
There is really no such thing as a list literal in Perl although it
is a convenient short-hand to describe an expression consisting
entirely of literals and comma operators evaluated in a LIST context.
There certainly is no such thing as a list literal in a scalar
context. There is such a thing as a slice in a scalar context.
Let us consider the two facts in question here.
A) scalar(1,2,3) same as scalar((1,2,3)[-1])
B) scalar(@foo[EXPR]) same as scalar((@foo[EXPR])[-1])
I'm not denying that there is a superficial similarity. However you
appeared to claim a _causual_ relationship (A=>B). There is no such
relationship. There is no general rule.
It should also be noted that
scalar(foo(),bar()) != scalar((foo(),bar())[-1])
Aha, so you want them to behave identically. ;-)
That has no meaning because the situations are not comparible.
my $bar = @foo[3]; # Currently: warn, I want: warn
my ($bar) = @foo[3]; # Currently: warn, I want: no warn
my $bar = @foo[1,2]; # Currently: no warn, I want: warn
my $bar = @foo[@q]; # Currently: no warn, I want: warn