merlyn posted an excellent node summarizing this statement. In it, you'll find that caller, in scalar context returns the package name. One useful item is localtime, which in scalar context returns a well formatted timestamp, while in list context returns individual portions of the date and time split out into individual elements. glob in scalar context returns the next item (you can repeat until it returns undef).

merlyn's list is here: On Scalar Context. It's very informative.

What this is (I believe) refering to is the fact that a function that returns a list in list context can return any scalar it wants in scalar context. Using the 'wantarray' builtin, a function could return:

sub my_func
{
  ...

  return @list_return if wantarray;
  return $scalar_return;
}
[download]

To find specific cases, you'd have to look at specific functions. Try the function reference at the end of Programming Perl for examples.

localtime, readline, flip-flop operator

Normally, $a = @array; will store the number of elements in the list in $a. That is not always the case, because of wantarray. For example:

$scalar = localtime();
print($scalar, "\n");
# "Mon Aug 23 11:31:16 2004"

@array = localtime();
$scalar = @array;
print($scalar, ':', join(',', @array), "\n");
# 9:16,31,11,23,7,104,1,235,1

@array = scalar(localtime());
$scalar = @array;
print($scalar, ':', join(',', @array), "\n");
# 1:Mon Aug 23 11:34:30 2004
[download]

Update: Fixed error pointed out by davorg

Normally, $a = ( ...list... ); will store the number of elements in the list in $a.

Did you test that before you wrote it?

$ perl -le '$a = (3, 4, 5); print $a'
5
[download]

I think you're confusing lists and arrays.

--
<http://www.dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

I did test it, but the last element of the list was the number of elements in the list... Fixed my original post.

humbly request you end my misery

# @users is an array of hashes.
for (@users) {
  if ($_{clue} <= 0) {
    kill($_);
  } else {
    print STDERR "User with clue found: your data may be invalid";
  }
}
[download]

The important thing to understand (and something that I clearly misunderstood ten years ago -- I still remember the feeling of egg on face) is that there simply is no such thing as a list in scalar context. A "list producing expression used in scalar context" does not produce a list. It just produces a single value, which is the last element in the comma-delimited expression. (That's as near as I can come to describing the right-hand-side.)

So the truth is that this construct:

my $a = ( 10, 20, 30, 40, 50 );
[download]

...is not generating a list in scalar context and then assigning the last element to $a. It's assigning the scalar value 50 to $a, that's it. There's no list, and the entity has a size of one.

B::Deparse's output is interesting when list-producing syntax is used in scalar context. There's no list. :)

perl -MO=Deparse -E '$x = (10,20,30); say $x'
[download]

There you'll see the comma operator at work doing what it's supposed to do in scalar context: throwing away the item on the lefthand, returning the one on the right.

> A "list producing expression used in scalar context" does not produce a list. It just produces a single value, which is the last element in the comma-delimited expression.

Maybe better phrased "a list-producing expression used in scalar context" will not produce an intermediate LIST which is then evaluated in scalar context, but a scalar is produced depending on the value.

  DB<102> scalar (a..d)
 => "1E0"

  DB<103> sub tst {a..d}

  DB<104> tst()
 => ("a", "b", "c", "d")

  DB<105> scalar tst()
 => "1E0"

  DB<106> scalar ("a", "b", "c", "d")
 => "d"

  DB<107> sub tst { @{[a..d]} }

  DB<108> scalar tst()
 => 4
[download]

I wonder if a listify operator could help avoiding bugs when changing the return expression of a sub.

Cheers Rolf

( addicted to the Perl Programming Language)

I wonder if a listify operator could help avoiding bugs when changing the return expression of a sub.

It might help (and indeed, I think Perl6 has the list operator — but don't quote me), but the context in which the  .. and  ... range/flip-flop operators act is usually pretty clear. scalar alone serves pretty well in this case and in general since it's very easy to induce list context, so easy that one almost gets the impression it's the default!

Clap with me davido :) If you believe in Lists in Scalar Context, Clap your Hands

merlyn, as usual, has the knack for expressing it more clearly than I could:

Re: Scalar context of slice




Dave