Re^2: The Boy Scout Rule

[Your Mother]

my $value = [ $x => $y ] -> [ $y <= $x ]; would not pass my code review.

I agree it’s confusing the first time and the => should be a skinny comma :P instead. That said, the Schwartzian transform is even more confusing the first time you see it. No one in a post 5.6 Perl world would suggest rewriting it with a bunch of temp arrays and for blocks. So, I advocate simple little idioms like the above when they offer something more than clever/pretty code.

So, thinking to possibly defend the clever/pretty one, I tried a Benchmark, which I'm not necessarily doing right so someone please jump in if it’s badly formed, and the one that might be the most semantically clear and I assumed would be the slowest is the fastest by a good measure. I forgot that List::Util is XS.

use strictures;
use Benchmark "cmpthese";
use List::Util "min"; # This is XS.

my @xy = ( [ 1, 0 ], [ 0, 1 ], [ 0, 0 ], [ 1, 1 ],
           [ 1_000_000, 999_999 ], [ 999_999, 1_000_000 ] );

my $m; # Avoid void in comparisons.
cmpthese(10_000_000, {
                   list_util => sub { $m = min(@$_) for @xy },
                   ternary => sub {
                       $m = $_->[0] < $_->[1] ? $_->[0] : $_->[1] for 
+@xy },
                   clever => sub {
                       $m = [ $_->[0], $_->[1] ]->[ $_->[0] <= $_->[1]
+ ] for @xy },
                  });

               Rate    clever   ternary list_util
clever     347584/s        --      -56%      -68%
ternary    792393/s      128%        --      -28%
list_util 1096491/s      215%       38%        --

[BrowserUk]

Several problems:

• With just 6 comparisons & assignments being run; the overhead of two subroutine calls -- the one you wrapped your tests in and the one Benchmarks wraps those in internally -- becomes a significant factor in the tests.

  Pass strings instead of subs to remove one layer of sub-call overhead; and allow benchmark to eval them into subroutines. (It's going to anyway!)

  Use an internal loop multiplier to re-balance the test/overhead.

• By passing your args wrapped in anonymous arrays -- thus forcing the ternary to do 3 dereferences; and the clever to do 4 dereferences; whereas List::Util only does one -- you bias the tests strongly in List::Util's favour.

  Most min() operations will operate on simple scalars so use those instead.

• (Minor.) There is little value in using different and big integers; they are all just IVs (or UVs) as far as the comparisons are concerned.

  Test for differences in ordering (branch/no branch) by coding separate tests.

The upshot is that the ordering makes no consistent difference (Ie. it flip flops from run to run); and that the ternary is hands down winner for the two simple scalars, common case:

use strictures;
use Benchmark "cmpthese";
use List::Util "min"; # This is XS.

cmpthese -1, {
    list_util_nb   => q[ my( $x, $y ) = ( 0, 1 ); my $m = min( $x, $y 
+)                for 1 .. 1000; ],
    ternary_nb     => q[ my( $x, $y ) = ( 0, 1 ); my $m =      $x < $y
+ ?    $x :  $y   for 1 .. 1000; ],
    clever_nb      => q[ my( $x, $y ) = ( 0, 1 ); my $m = [     $x, $y
+ ]->[ $x <= $y ] for 1 .. 1000; ],
    list_util_b    => q[ my( $x, $y ) = ( 1, 0 ); my $m = min( $x, $y 
+)                for 1 .. 1000; ],
    ternary_b      => q[ my( $x, $y ) = ( 1, 0 ); my $m =      $x < $y
+ ?    $x : $y    for 1 .. 1000; ],
    clever_b       => q[ my( $x, $y ) = ( 1, 0 ); my $m = [    $x, $y 
+]->[  $x <= $y ] for 1 .. 1000; ],
};


__END__
C:\test>junk30
               Rate clever_b clever_nb list_util_nb list_util_b ternar
+y_b ternary_nb
clever_b     1210/s       --      -11%         -67%        -70%      -
+79%       -80%
clever_nb    1356/s      12%        --         -63%        -67%      -
+76%       -78%
list_util_nb 3694/s     205%      172%           --         -9%      -
+34%       -40%
list_util_b  4062/s     236%      200%          10%          --      -
+28%       -33%
ternary_b    5630/s     365%      315%          52%         39%       
+ --        -8%
ternary_nb   6107/s     405%      351%          65%         50%       
+ 8%         --

C:\test>junk30
               Rate clever_nb clever_b list_util_b list_util_nb ternar
+y_b ternary_nb
clever_nb    1297/s        --      -5%        -68%         -69%      -
+75%       -77%
clever_b     1372/s        6%       --        -66%         -67%      -
+74%       -75%
list_util_b  4078/s      214%     197%          --          -3%      -
+22%       -27%
list_util_nb 4190/s      223%     205%          3%           --      -
+20%       -25%
ternary_b    5228/s      303%     281%         28%          25%       
+ --        -6%
ternary_nb   5556/s      328%     305%         36%          33%       
+ 6%         --

List::Util::min() will obviously win in both speed and clarity for the min( @array ) case.

[Your Mother]

Thank you for the detailed fix. Unbiasing benchmarks is something I have been needing to improve for a long time.