Some people say that lists don't exist in scalar context (and I disagree, but that's really a pointless discussion), but if we assume they do exist, then the default behaviour of a list is scalar context is to return its last element:

print scalar(1, 2, 3);
[download]

prrint the 3.

(Update) and the last element of an empty list is not defined, which is why you get the warning.

There's no default.

If you say there's such a thing as a list in scalar context, it's because you're talking about list literals or the list operator. If so, the only behaviour for a list in scalar context is to return its last element after evaluating it in scalar context. undef is returned for empty lists.

# List literal in list context
>perl -E"sub c { @a=qw(d e f g); @a } say('a', 'b', c())"
abdefg

# List literal in scalar context
>perl -E"sub c { @a=qw(d e f g); @a } say(scalar('a', 'b', 'c'))"
c

# List literal in scalar context
>perl -E"sub c { @a=qw(d e f g); @a } say(scalar('a', 'b', c()))"
4   # scalar(@a)
[download]

... the default behaviour of a list is scalar context is to return its last element...

... depending on associativity and precedence and arity and the presence of any prototypes in the surrounding expression which may change any of the former, so the choice of the word "default" is, at best, misleading.

So what would be a better phrasing, in your opinion?
Perl 6 - links to (nearly) everything that is Perl 6.

I thought the 3 variants are equivalent,

Note that none of them is a list in scalar context - there is no such thing on the language level (after all, it's context that makes list).

qw,, in scalar context returns undef, however in list context (assigning to an array), it will set the array to an empty array.

Similarly for ().

The real issue here is the differences between returning data in list and scalar context.

So, if you substitute your print statements for these, you will get '0' printed 3 times.

my @a;
print(scalar(@a=empty_list1()),"\n");
print(scalar(@a=empty_list2()),"\n");
print(scalar(@a=empty_list3()),"\n");
[download]

Yes, but not for the reason you're implying. You're thinking @a is evaluated in scalar context when it's not. Both operands of the list assignment (@a and empty_listX()) are evaluated in list context.

If @a is an operand of the list assignment, what's the operand of the scalar() pseudo-operator? The list assignment. scalar() causes the list assignment to be evaluated in scalar context. In scalar context, the list assignment operator returns the number of elements returned by its right hand side operand.

Since it doesn't matter to what you are assigning, you could just as easily have written

print(scalar(()=empty_list1()),"\n");  # 0
print(scalar(()=empty_list2()),"\n");  # 0
print(scalar(()=empty_list3()),"\n");  # 0
print(scalar(()=(4..6)       ),"\n");  # 3
[download]

the function is called in scalar context, so that the number of list elements should be printed.

That's not what scalar context does. Scalar context simply lets operators know they can only return a single scalar value. What that value is up to each individual operator.

Some operators (e.g. @array, grep) return the number of values that would otherwise be returned, but that's far from typical. The most common practice is to return exactly the same thing in every context.

Looking at your code, you have a number of subs evaluated in scalar context. That means their return expression is evaluated in scalar context. Your code is equivalent to

print(scalar( @{ [] } ),"\n");
print(scalar( qw,,    ),"\n");
print(scalar( ()      ),"\n");
[download]

which the tokenizer changes into

print(scalar( @{ [] } ),"\n");
print(scalar( ()      ),"\n");
print(scalar( ()      ),"\n");
[download]

In the first case, you have an array lookup in scalar context. That returns the number of elements in the array being looked up, which is zero.

In the second and third case, you have a list literal in scalar context. That returns the last element of the list after evaluating it scalar context. If the list is empty, undef is returned.

the function is called in scalar context, so that the number of list elements should be printed.

That's not what scalar context does. Scalar context simply lets operators know they can only return a single scalar value. What that value is up to each individual operator.

I should have been clearer with my wording here. I wanted to say: the function is called in scalar context, and if it returns an array, the number of array elements should be printed

I now understand from the replies that my mistake was to assume that lists and arrays behave the same in scalar context. Thanks to all of you for clarifying this.

-- 
Ronald Fischer <ynnor@mm.st>