I did some quick playing with the methods shown here just to get an idea of speed. Before now i've never looked at List::Util because I could do it all myself but now I think I see the light. It provides an astounding speed bonus.

use strict;
use warnings;
use Benchmark ;
use List::Util qw(max shuffle);

   
my @a = (1..500_000);
my @b = shuffle (1..500_000);
my $greatest;

timethese(25, {
     'sort_shuffled' =>
          sub {($greatest)=sort{$b<=>$a}@b;},
     'grep_shuffled' =>   
          sub { 
              grep($greatest=($_>$greatest)?$_:$greatest,@b); 
          },
     'for_shuffled' => 
          sub {
              $greatest = 0;
              for (@b) { $greatest = $_ if $_ > $greatest; }
          },
     'max_shuffled' => 
           sub { max(@b) },
     'sort_inorder' =>
          sub {($greatest)=sort{$b<=>$a}@a;},
     'grep_inorder' =>   
          sub { 
              grep($greatest=($_>$greatest)?$_:$greatest,@a); 
          },
     'for_inorder' => 
          sub {
              $greatest = 0;
              for (@a) { $greatest = $_ if $_ > $greatest; }
          },
     'max_inorder' => 
           sub { max(@a) }
});

__DATA__
Benchmark: timing 25 iterations of for_inorder, for_shuffled, grep_ino
+rder, grep_shuffled, max_inord
er, max_shuffled, sort_inorder, sort_shuffled...
for_inorder:  5 wallclock secs ( 5.17 usr +  0.00 sys =  5.17 CPU) @  
+4.83/s (n=25)
for_shuffled:  4 wallclock secs ( 3.55 usr +  0.00 sys =  3.55 CPU) @ 
+ 7.05/s (n=25)
grep_inorder:  4 wallclock secs ( 3.75 usr +  0.00 sys =  3.75 CPU) @ 
+ 6.67/s (n=25)
grep_shuffled:  4 wallclock secs ( 3.70 usr +  0.00 sys =  3.70 CPU) @
+  6.75/s (n=25)
max_inorder:  1 wallclock secs ( 0.89 usr +  0.00 sys =  0.89 CPU) @ 2
+8.09/s (n=25)
max_shuffled:  1 wallclock secs ( 0.91 usr +  0.00 sys =  0.91 CPU) @ 
+27.59/s (n=25)
sort_inorder:  1 wallclock secs ( 1.73 usr +  0.02 sys =  1.75 CPU) @ 
+14.28/s (n=25)
sort_shuffled: 36 wallclock secs (34.34 usr +  0.05 sys = 34.39 CPU) @
+  0.73/s (n=25)
[download]

I was curious if anyone could explain why grep is so much faster thant the for? Ohh and how do people do those cool comparison benchmarks with the chart?