say [+] @_;
[download]

sub sum{eval join"+",@_}
[download]

eval join"+",@_

Of course, that's not safe if @_ includes a text element with a ";" in it.

But in the spirit of silly shortenings, how about some recursion?

sub sum { @_ && pop(@_) + sum(@_) }
[download]

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

Regarding recursion: I also thought about it, but it's longer. Your's can be shortened:

sub sum {@_&&(pop)+sum(@_)}
[download]

---

s$$([},&%#}/&/]+}%&{})*;#$&&s&&$^X.($'^"%]=\&(|?*{%
+.+=%;.#_}\&"^"-+%*).}%:##%}={~=~:.")&e&&s""`$''`"e

Besides brevity, it might also execute faster since Util.xs informs us that sum() is coded in C, as NV sum(...)

use List::Util qw(sum);
print sum (my @arr = qw( 1 3 5 6));
[download]

I was never very good at Golf, but here goes:

perl -le'@_=1..5;$s+=$_ for@_;print$s'
[download]

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

perl -le'@a=(1,3,5,6);$"="+";print eval"@a"'
perl -le'@a=(1,3,5,6);$,="+";print@a'|bc
[download]

This is not exactly golf, and works only for nonnegative integers.

#!perl

use warnings;
use strict;

{
my $adder = '
        G
        s/^ *\([0-9]*\) *\n\([0-9]*\)$/0\1pm0\2nb0/;td;d;
        :d;s/n\(\(b\).*0\|\)[^0]*$/nb98765432109876543210a0123456789\2
+/;
        s/\(.\)\(p.*\)\(.\)\(n.*\1\).*a.*\3/\2\4\3/;
        s/^0*\(.*\)p\(.*m\)0*\(.*\)\(.\).\{11\}$/0\1p\4\20\3/;
        /m0*n.*0/!bd;
        s/^\(.*\)p\(.*\)m.*/\1\2/;s/^0*//;
        h;$!d
';
$adder =~ s/;/\n/g; # some seds don't like semicolons
sub printsum { 
        open my $SED, "|-", "sed", $adder or die "error running sed: $
+!";
        print $SED int($_), "\n" or die "error writing to sed: $!" 
                for @_;
        close $SED or die "error closing sed: $!";
}
}

my @array = (1,3,5,6);
printsum(@array);

__END__
[download]

Update 2007-12-06: see Re^2: --- adding a column of integers

Update 2011-10-29: see also (almost) foldl.

Not golf at all, but an excellent obfuscation! :)

The obvious way to golf it:

sub sum { my$t;$t+=$_ for@_;$t }
[download]

The eval approaches are shorter, but unsafe. It’s your call whether that’s acceptable. For real code, it’s not. But in real code I’d use List::Util.

Makeshifts last the longest.

Obvious, maybe... but not quite correct. You need a space before your for.

-sauoq
"My two cents aren't worth a dime.";