Passing arguments

Many functions, methods or subs (no matter how you call them) need some arguments. In Perl TIMTOWTDI, but some are faster than others. I'll compare eight ways to get arguments passed to a sub.

The first doesn't actually copy the args, but only saves the reference to the argument array in a variable:

sub array_ref {
 my $args = \@_;
 return $args->[0];
}

The second assigns the values of the argument array to individual variables:

sub array_copy {
 my ($first, $second, $third) = @_;
 return $first;
}

Shift off the values into individual variables one by one and remove them from the argument array:

sub shift_off {
 my $first = shift;
 my $second = shift;
 my $third = shift;
 return $first;
}

Copy the whole argument array to a self-defined variable:

sub copy_once {
 my @args = @_;
 return $args[0];
}

Copy the whole argument array and assign each value to a named variable:

sub copy_twice {
 my @args = @_;
 my $first = $args[0];
 my $second = $args[1];
 my $third = $args[2];
 return $args[0];
}

Pass the values using named arguments and copy all of them into one arguments hash:

sub named {
 my %args = @_;
 return $args{first};
}

Pass the values using named arguments and copy them to named variables:

sub named_copy {
 my %args = @_;
 my $first = $args{first};
 my $second = $args{second};
 my $third = $args{third};
 return $first;
}

Let Moose and its helper modules assign the values into named variables:

class Bench::Moose {
 method moose(Int $first, Str $second, Any $third) {
 return $first;
 }
}

I expect the first way, array_ref to be the quickest and Moose to be the slowest. Moose also enforces some data types for the values which slows down things even more. I included it just to see the results.

I didn't expect named arguments to be that slow. The additional copy to named variables drop them to less than one third of the fastest way. Moose is even slower than I expected, but isn't comparable to the others, because so much additional stuff is being done (type checks, $self init, some method wrappers, etc.).

Here is sub_arguments_benchmark.zip.