Gunnar Hjalmarsson <no*****@gunnar.cc> wrote in message news:<jG******************@newsb.telia.net>...
no****@mail.com wrote: Gunnar Hjalmarsson wrote: Because an array slice is a LIST, not an array. A LIST returns
the last element when evaluated in scalar context, as opposed to
an array which returns the number of elements when evaluated in
scalar context.
There is no such thing in Perl as a LIST in a scalar context!
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.
A slice in a scalar context returns the last element.
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])
IMNSHO an array slice in an obviously scalar context should throw a
warning.
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
