In my testing $result always gets the value "c" (I assume because it's the last value). But is this guaranteed? Where is this documented?

Binary "," is the comma operator. In scalar context it evaluates its left argument, throws that value away, then evaluates its right argument and returns that value. This is just like C's comma operator.

Do note that if you first put them values in an array and return that, you get something else entirely back: the number of elements in the array.

sub get_values { my @a = ("a", "b", "c"); return @a }
$x = get_values;  # 3
[download]

And taking this one step further: How can I get "a" and "c"? I know that I can just use three variables and ignore the second one, but I guess there's a better way to do that.

my @some = (get_values)[0,2];
[download]

But is this guaranteed?

No, not from the perspective of the sub's caller. It's dependent on the implementation of the sub.

For example, consider the following two functions that behave identically in list context.

>perl -le"sub f { 'a','b','c' } my @v=f(); print for @v"
a
b
c

>perl -le"sub f { my @a = ('a','b','c'); @a } my @v=f(); print for @v"
a
b
c
[download]

In scalar context, however, they return drastically different results.

>perl -le"sub f { 'a','b','c' } my $v=f(); print $v"
c

>perl -le"sub f { my @a = ('a','b','c'); @a } my $v=f(); print $v"
3
[download]

If the sub doesn't define how it behaves in scalar context (which is the case for many subs that return lists), you have two options.

• You can assign to a list with the undesired elements undefined.

  (my $first)                   = f();
  (my $first, undef, my $third) = f();
  (undef, my $second)           = f();
  [download]

  The above can also be written as

  my ($first)                = f();
  my ($first, undef, $third) = f();
  my (undef, $second)        = f();
  [download]

• You can filter out the undesired returned values. This is usually done using a list slice (see perldata).

  my $first           = ( f() )[0];
  my ($first, $third) = ( f() )[1,3];
  my $second          = ( f() )[2];
  [download]

For your last question, you could do something like
my ($first, $third) = (get_values())[0,2];

Chris

The calling context is important. Consider:

use warnings;
use strict;

my $result =  get_values ();

print "$result\n";

my @results = get_values ();

print "@results";

sub get_values {
    return ("a", "b", "c");
}
[download]

Prints:

c
a b c
[download]

$ perl -wl
sub get_values {
    return ('a', 'b', 'c');
}

my $result = undef;
$result = get_values();
print $result;

($result) = get_values();
print $result;
__END__
c
a
[download]

$ perl
sub check_context {
    # True
    if ( wantarray ) {
        print "List context\n";
    }
    # False, but defined
    elsif ( defined wantarray ) {
        print "Scalar context\n";
    }
    # False and undefined
    else {
        print "Void context\n";
    }
}

my @x       = check_context();  # prints 'List context'
my %x       = check_context();  # prints 'List context'
my ($x, $y) = check_context();  # prints 'List context'

my $x       = check_context();  # prints 'Scalar context'

check_context();                # prints 'Void context'
__END__
List context
List context
List context
Scalar context
Void context
[download]