Velocity Reviews > Perl > obtaining lengths of slices

# obtaining lengths of slices

Griff
Guest
Posts: n/a

 08-04-2004
@array1 = (1,2,3);

\$length = @array1[1,2]; # assigning a slice to \$length

print "length = \$length"; # prints 3 (ie length of array not length of slice)

@slice = @array1[1,2];

print "\n";

\$length = @slice; # assigning slice-converted-into-array to \$length

print "length = \$length"; # prints 2

----------------------------------------

Why the difference ?

Thanks - Griff

Guest
Posts: n/a

 08-04-2004
Griff wrote:
> @array1 = (1,2,3);
>
> \$length = @array1[1,2]; # assigning a slice to \$length
>
> print "length = \$length"; # prints 3 (ie length of array not length of slice)
>
> @slice = @array1[1,2];
>
> print "\n";
>
> \$length = @slice; # assigning slice-converted-into-array to \$length
>
> print "length = \$length"; # prints 2
>
> ----------------------------------------
>
> Why the difference ?

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.

--
Email: http://www.gunnar.cc/cgi-bin/contact.pl

nobull@mail.com
Guest
Posts: n/a

 08-04-2004
Gunnar Hjalmarsson <(E-Mail Removed)> wrote in message news:<Oj3Qc.99995\$(E-Mail Removed)>...
> 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!

A slice in a scalar context returns the last element.

IMNSHO an array slice in an obviously scalar context should throw a
warning. This would be much more use than the downright dumb "Scalar
value @foo[1] better written as \$foo[1]" warning we have now. I quite
often want to use a slice that happens _now_ to be a single element
slice but which earlier or later in the evolution of the code may have
more elements. On the other hand can see no reason to ever
intensionally use an array (or hash) slice in a context that is known
at compile time to be scalar.

(It can make sense to use a list slice in a scalar context. It also
can make sense to use an array slice in a subroutine return where the
context is not known until runtime.)

This newsgroup does not exist (see FAQ). Please do not follow-up here
without pointing this out.

Joe Smith
Guest
Posts: n/a

 08-04-2004
Griff wrote:

> @array1 = (1,2,3);
> \$length = @array1[1,2]; # assigning a slice to \$length
> print "length = \$length"; # prints 3 (ie length of array not length of slice)

The number 3 is not what you think it is.

@array1 = (10,20,30);
\$lastitem = @array1[1,2];
print "Last item returned by the comma operator is: \$lastitem\n";

\$length_of_slice = () = @array1[1,2];
print "Using a dummy list returns the length of \$length_of_slice\n";

-Joe

Guest
Posts: n/a

 08-04-2004
http://www.velocityreviews.com/forums/(E-Mail Removed) 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);

(It generates "Useless use ... in void context" warnings, but \$scalar
is assigned he value of the last element.)

> A slice in a scalar context returns the last element.

What's the difference compared to a list literal (besides the warnings)?

> IMNSHO an array slice in an obviously scalar context should throw a
> warning.

Aha, so you want them to behave identically.

--
Email: http://www.gunnar.cc/cgi-bin/contact.pl

nobull@mail.com
Guest
Posts: n/a

 08-05-2004
Gunnar Hjalmarsson <(E-Mail Removed)> wrote in message news:<jGaQc.7204\$(E-Mail Removed)>...
> (E-Mail Removed) 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

Guest
Posts: n/a

 08-06-2004
(E-Mail Removed) wrote:
>>(E-Mail Removed) wrote:
>>>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;

<interesting discussion snipped>

Thanks for the lecture!

--
Email: http://www.gunnar.cc/cgi-bin/contact.pl