At compile-time, the context is set to one of the following:

• Void
• Scalar
• List
• From subroutine's caller

An operator cannot control context at run-time. It cannot be any other way because operators are executed after their operands. Consider

@x = ( f(), g(), h() );
[download]

There are four ops on the RHS of the assignment. In the order they are called, they are:

1. entersub(f): Calls f and leaves result on the stack
2. entersub(g): Calls g and leaves result on the stack
3. entersub(h): Calls h and leaves result on the stack
4. list: Filters all but the last element off the stack in scalar context. No-op otherwise

The list operator never has a chance to control the context of its operands since they've already been evaluated by the time the list operator is evaluated.

That is actually the source of a known bug in Perl. What follows explains it. At compile-time, the contexts in which the above operators are evaluated are set as follows:

1. entersub(f): List
2. entersub(g): List
3. entersub(h): List
4. list: List [*]

And it works well. It also works well in scalar context:

$x = ( f(), g(), h() );
[download]

1. entersub(f): Void
2. entersub(g): Void
3. entersub(h): Scalar
4. list: Scalar

And in void context:

( f(), g(), h() );
1;
[download]

1. entersub(f): Void
2. entersub(g): Void
3. entersub(h): Void
4. list: Void

And now we're left with the fourth case:

sub { ( f(), g(), h() ) }
[download]

1. entersub(f): From subroutine's caller
2. entersub(g): From subroutine's caller
3. entersub(h): From subroutine's caller
4. list: From subroutine's caller

If we call the subroutine as

@x = sub { ( f(), g(), h() ) }->();
[download]

then all's fine:

1. entersub(f): From subroutine's caller: List
2. entersub(g): From subroutine's caller: List
3. entersub(h): From subroutine's caller: List
4. list: From subroutine's caller: List

But if we call the subroutine as

$x = sub { ( f(), g(), h() ) }->();
[download]

we have a bug!

1. entersub(f): From subroutine's caller: Scalar: should be void!
2. entersub(g): From subroutine's caller: Scalar: should be void!
3. entersub(h): From subroutine's caller: Scalar
4. list: From subroutine's caller: Scalar

Some code to support what I said:

use strict;
use warnings;

sub cx { 
   print !defined(wantarray()) ? 'v'
       : !wantarray()          ? 's'
       :                         'l';
}

my ($x, @x);

print('v:  ');             ( cx(), cx(), cx() )      ;  print("\n");
print('cv: ');       sub { ( cx(), cx(), cx() ) }->();  print("\n\n");
print('s:  ');  $x =       ( cx(), cx(), cx() )      ;  print("\n");
print('cs: ');  $x = sub { ( cx(), cx(), cx() ) }->();  print("\n\n");
print('l:  ');  @x =       ( cx(), cx(), cx() )      ;  print("\n");
print('cl: ');  @x = sub { ( cx(), cx(), cx() ) }->();  print("\n");
[download]

v:  vvv
cv: vvv

s:  vvs   \ mismatch
cs: sss   /

l:  lll
cl: lll
[download]

A practical difference:

use strict;
use warnings;

my $x;
$x =       ( 'abc', 'def' )      ;  # Warns
$x = sub { ( 'abc', 'def' ) }->();  # Doesn't warn
[download]

Useless use of a constant in void context at line 5.
[download]

* — A list op in list context is subsequently optimized away since it's a no-op there. This does not affect the results.