For example:

    return reduce(sub { $a * $b; }, 1, (1..$n));

    reduce { $a * $b } 1..$n;

    my $output = 1;
        for my $i (1..$n) {
            $output *= $i;
    }

    $output *= $_ for (1..$n)

    $output *= $_ for (1..$n)

I think this is an interesting point (in a discussion about readability), do non-perl coders think the one-liner (with 'for' suffix) is more or less readable?

(I also prefer explicit return for maintenance reasons, except possibly in one-line subs)

It does since 5.005 - so for a good long time now :-)

The reduce version (again, I'm unsure of const mem req). Comes in at ~1.4s:

This would allocate the array I'm afraid. You'd could use something liek List::Gen's reduce() to get around that.

def function(x, y, z):

versus

sub function { my ($x, $y, $x) = @_; }

The overhead is only really the 'my = @_;' chars, but it is annoying. On the other hand, it does allow you to do things like partially unpack args and pass the rest as a bundle to a super class.

  def method(self, *args):
    a, b = args[:2]
    super(self).method(*args[:2])

And with @_, you're free to use positional arguments, named arguments, variable arity, etc. without penalty. Some languages only give you some of that.

  use Method::Signatures::Simple;

But you might instead want to look at this (or similar with Moose support) to get simple type declarations:

http://search.cpan.org/~barefoot/Method-Signatures-20120523/...