How do I get the first item from a function that returns an array in Perl?

my $item = (function_returning_list())[0];

Functions cannot return arrays, they can return the contents of an array (i.e. a list). Lists are indexed starting at 0, so the first item of a function's return is (func)[0]. You could also say

my ($item) = function_returning_list();

This puts function_returning_list in list context and does assignment (in order) to the variables in the left-hand-side list.

It is important to note that

sub function_returning_list {
    return ("a", "b", "c")
}

my $item = function_returning_list();

will likely not do what you expect. The $item variable will be assigned "c". This is because there is no such thing as a list in scalar context. Instead, you have the comma operator in scalar context, and that evaluates the lefthand expression in void context, discards the result, then evaluates the righthand side in scalar context.

I call a sequence (rather than a list) and is useful if a few situations like C-style for loops.

First, [1] is the second item in the list since Perl uses 0-based indices.

Second, you need the function's return to be evaluated in list context in order to have a list to access.

(functionReturningArray())[0]

Going one step further than the discussion below Chas's answer, there's no such thing as a list period.

Unlike Python which has the tuple type filling this role, Perl's lists are entirely a construct of the stacks in the compiler/interpreter. This is why you can not take a reference to a list.

Just like python's use of tuples, perl automatically pushes and shifts its stack to move around groups of variables when a construct such as the = assignment operator is used. (Perl's precedence rules are what require the parenthesis, since = binds tighter than ,). The macro level difference between Perl's and Python's mechanisms is that context propagates through the entire expression.

So when in scalar context, that context is distributed to each of the , operators and the operator executes its left side in void context and its right side in scalar context which it then returns. However in list context the , operator pushes its arguments onto the stack, all of which are executed in list context. The stack is then passed across the assignment operator and then shifted into the lvalue. The stack/list itself is immutable to Perl level code, it's modification tools are effectively all of Perl's syntax.

So while it is incorrect to refer to a list in scalar context (because such a thing can not happen), you can refer to the behavior of list like syntactic constructs (constructed by the , operator, constructed by an array slice or list slice). In scalar context, the behavior of list like constructs is to return the last element of the list. How this is achieved is up to the operators in the expression. this is of course in contrast to the behavior of arrays in scalar context which return their length.

To clarify with an example and finally obey the rules and actually answer the question:

Assuming my @array = (10, 11, 12);

• scalar context

    my $val = (10, 11, 12);        # $val is 12
    my $val = (10 .. 20)[0 .. 5];  # $val is 15      
    my $val = @array;              # $val is 3
    my $val = function();          # $val is the last executed expression
  

  • so if function ends with 10, 11, 12 then the value will be 12
  • if it instead is @array then the value will be 3
  • and if it ends with 10, 11, 12, @array the value is also 3
    
    

• list context

    my ($val) = (10, 11, 12);        # $val is 10
    my ($val) = (10 .. 20)[0 .. 5];  # $val is 10
    my ($val) = @array;              # $val is 10
    my ($val) = function();          # $val is the first executed expression
                                     # in the last statement.
  

  • so if function ends with 10, 11, 12 then the value will be 10
  • if it instead is @array then the value will be 10
  • and if it ends with 10, 11, 12, @array the value is also 10
    
    

• and for completeness, list context grabbing the whole list into an array

    my @val = (10, 11, 12);        # @val is 10, 11, 12
    my @val = (10 .. 20)[0 .. 5];  # @val is 10, 11, 12, 13, 14, 15
    my @val = @array;              # @val is 10, 11, 12
    my @val = function();          # @val is the last executed statement
  

  • so if function ends with 10, 11, 12 then @val will be 10, 11, 12
  • if it instead is @array then @val will be 10, 11, 12
  • and if it ends with 10, 11, 12, @array then @val will be 10, 11, 12, 10, 11, 12