first is pure-Perl and does not have short-circuiting behaviour.

And if you look at the the source just before the pure perl reduce definition we find:

eval <<'ESQ' unless defined &reduce;

# This code is only compiled if the XS did not load
[download]

:-)

So the reduce() in question may, or may not, be pure perl.

Oops.

Interesting, also, that the XS version does short-circuit. I looked at the source and thought I could see that, but I don't know XS so to be sure, I tested. And lo:

$ perl -MList::Util=first -le'@_=(0)x100; first { ++$a; $_ == 0 } @_; 
+print $a'
1
[download]

Hmm.

Makeshifts last the longest.

Oops.

If it's any comfort I did exactly the same sort of thing once :-)

I did... :)

P:\lib\auto\List\Util>strings Util.dll | grep Usage
Usage: List::Util::reduce(block, ...)
Usage: List::Util::first(block, ...) <<<<<<<<<<<<<<<<<<
Usage: Scalar::Util::dualvar(num, str)
Usage: Scalar::Util::blessed(sv)
Usage: Scalar::Util::reftype(sv)
Usage: Scalar::Util::refaddr(sv)
Usage: Scalar::Util::weaken(sv)
Usage: Scalar::Util::isweak(sv)
Usage: Scalar::Util::readonly(sv)
Usage: Scalar::Util::tainted(sv)
Usage: Scalar::Util::isvstring(sv)
Usage: Scalar::Util::looks_like_number(sv)
Usage: Scalar::Util::set_prototype(subref, proto)
[download]

Weird.

use Benchmark qw(cmpthese);
use List::Util qw(first);

@_= ( (0)x1000, 1, (0)x8999 );

cmpthese -1, {
    func => sub { first { $_ == 1 } @_ },
    imper => sub { for ( @_ ) { next unless $_ == 1; return $_ } },
}
__END__
          Rate imper  func
imper 518950/s    --  -20%
func  649177/s   25%    --
[download]

Makeshifts last the longest.

This is closer to what I was doing

#! perl -slw
use strict;
use Benchmark qw[ cmpthese ];
use List::Util qw[ first ];

our @array = 1 .. 100_000;

cmpthese( -1, {
    func_10th => q[ 
        my $first = first{ length > 3 } @array;
#        print "F:$first";
    ],
    iter_10th => q[
        my $first;
        for ( @array ) {
            next unless length > 3;
            $first = $_;
            last;
        }
#        print "I:$first";
    ],
    func_last => q[ 
        my $first = first{ length > 5 } @array;
#        print "F:$first";
    ],
    iter_last => q[
        my $first;
        for ( @array ) {
            next unless length > 5;
            $first = $_;
            last;
        }
#        print "I:$first";
    ],
});
__END__
P:\test>381208
            Rate func_last iter_last func_10th iter_10th
func_last 22.0/s        --      -16%      -98%      -99%
iter_last 26.1/s       18%        --      -98%      -99%
func_10th 1196/s     5336%     4488%        --      -56%
iter_10th 2706/s    12201%    10282%      126%        --
[download]

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
"Memory, processor, disk in that order on the hardware side. Algorithm, algorithm, algorithm on the code side." - tachyon