Note that a subroutine doesn't return an array, but rather a list. That can make a lot of difference. Consider this code:

use 5.010;
{
   my @a = (1, 2, 3);
   sub a {
       return @a;
   }
}

my @x = a();
push @x, 4;
say a();
[download]

You can't have everything and a pony...

Ideally you would have the choice, and perl as it happens offers this choice.

Most of the time you want a copy (on the way in and on the way out of a subroutine), because it decouples the subroutine: You can just assume that your parameters are unchanged by a subroutine and that you can change the result of a subroutine without having to think about any side effects if you further process that result (moritz gave a simple example of these side effects).

Think about the last 10 subroutines you wrote. If you changed all these subroutines to return pointers to arrays instead of arrays (or vice versa) would you notice any speed difference? Probably not. And even if you did, could you have the same difference by only speeding up one of these 10? Probably. So is it faster to find that one subroutine to speed up or is it faster to think of how to avoid any side effects any time you write a call to a subroutine and find the bugs afterwards if you make a single mistake there

#!/usr/bin/perl -w
use strict;

my $arraylength=1000;

open(FOUT,">", "/dev/null");
my $now=time();

for (my $j=0; $j<100_000; ++$j) {

  # create a 1000 array
  my @array;
  for (my $i=0; $i<$arraylength; ++$i) { push(@array, rand()); }

  passed_array(\@array);
  sub passed_array {  print FOUT $_[0]->[rand($arraylength)]; }

}
print "Time: ".(time()-$now)." seconds\n";
close(FOUT);
[download]

That's a bad benchmark then. Flattening a thousand-element array into subroutine parameters requires putting a thousand SVs on the Perl 5 stack. Passing the same array by reference requires putting a single RV on the Perl 5 stack. Which one do you think will take longer?

Agree with chromatic. I tried following:

use Benchmark qw(cmpthese);

my @array = (1..1000);

cmpthese(-2, {
    call     => sub { foo(@array);  },
    call_ref => sub { foo(\@array); },
});

sub foo { }
[download]

and got that call with reference is much faster:

              Rate     call call_ref
call      168822/s       --     -93%
call_ref 2575003/s    1425%       --
[download]

-- Roman

actually, perl seemed smart enough to recognize that if it sees a call with an array, it can pass the array as a pointer. when I tried it, call(@longarray) and call(\@longarray) took almost the same amount of time. so, I do not believe perl literally puts all 1,000 elements of longarray on the stack and then pops it, as C would do.

the mystery to me was why perl was not smart enough to do the same when I do return @longarray.

apparently, this has to do with arrays vs. lists. I do understand now that the two are different. alas, I do not understand what the purpose of a list is. it doesn't seem to make things faster, and is more restrictive. besides, the difference is confusing. if sub's returned arrays, then they could easily be assigned back to arrays, no matter how long.

thanks everyone, though.

Just like the only thing you can pass to a sub is a list of scalars, the only thing you can return from a sub is a list of scalars.

You are evaluating an array in list context. An array in list context returns a list of its elements.

#!/usr/bin/perl
use strict;
use warnings;
use Benchmark ":all";
my $len = 1_000;
sub returnlist { my @rray = map({rand()} (1..$len)); return( @rray); }
sub returnref  { my @rray = map({rand()} (1..$len)); return(\@rray); }
cmpthese(10_000, {
    "returnlist" => sub { my  @foo = returnlist(); },
    "returnref"  => sub { my ($foo) = returnref(); },
});
__END__
            Rate returnlist  returnref
returnlist 633/s         --       -24%
returnref  829/s        31%         --
[download]

# perl -v
This is perl, v5.10.1 (*) built for i686-cygwin-thread-multi-64int