Question

Suppose we have a subroutine returning a reference

sub aspirin {
    my @items = qw(some items in here);
    return \@items;
}

And another subroutine taking an array reference

sub beetroot (\@) {
    my $lst = shift;
    print "$_\n" for @$lst;
}

I want to get the array from aspirin and feed beetroot with it. I would like to do something like (approach A)

my $L = aspirin;
beetroot $L;

But the interpreter complains, and I need to do the following instead (approach B):

my $L = aspirin;
beetroot @$L;

So my questions are:

• Why isn’t the approach A working? The argument is actually an Array reference, which is what we want;
• Is a dereference without assignment (like the one in approach B) requiring the copy of the whole list content? (I guess not, since there’s no explicit copy).

Thanks for your answers

Answer 1

Perl prototypes exist to modify the behaviour of the parser, which is rarely needed. This is no exception.

If “beetroot” doesn’t have any other arguments then you should just use @_ instead of an array reference.

sub aspirin {
    my @items = qw'some items in here';
    return @items if wantarray; # return a list in list context
    return \@items;
}

sub beetroot {
    print "$_\n" for @_;
}

my $L = aspirin;
beetroot @$L;

# the follow examples require the version of aspirin from this answer

my @L = aspirin;
beetroot @L;

beetroot aspirin; # aspirin called in list context

This will have the added benefit that you don’t have to work around the parser if you just want to input a list of elements.

This works on the new version, but not the version in the question.

beetroot qw'some items in here';
beetroot aspirin; # aspirin called in list context

To get it to work with the one in the question, you have to create an anonymous array. Interesting enough, this also works with the version in this answer.

beetroot @{ [qw'some items in here'] };
# the follow examples use the version of aspirin from this answer
beetroot @{ [aspirin] };
beetroot @{ scalar aspirin };
beetroot @{ aspirin };

---

If you really want “beetroot” to work with array references.
I would write it this way.

sub beetroot{
  my($lst) = @_; # similar to my $lst = shift
  print "$_\n" for @$lst;
}

my $L = aspirin;
beetroot $L;

my @L = aspirin; # using the aspirin from this answer
beetroot \@L;

beetroot [qw'some items in here'];
# the follow examples use the version of aspirin from this answer
beetroot scalar aspirin; # force aspirin to return an array reference
beetroot [ aspirin ]; # copy the array

I would only write it this way if you want to use references to reduce the memory footprint of Perl, or you have other inputs to “beetroot“.