sub insertQuarter {
    my ($coin) = @_;
    (defined($coin) && $coin == 25) 
        || errorHandler(You must insert 25 cents");
    initializeGame();
    startGame();
}

##</code><code>##

#!/usr/bin/perl

use strict;
use warnings;

use Benchmark qw(:all);

## -- Sub -----------------------------------------------------------

sub assert {
    my $cond = shift;
    $cond || die "Test is wrong";
}

sub SubAssert {
    my ($test) = @_;
    assert($test < 50);
    return $test; 
}

sub assertNoOp {}

sub SubAssertNoOp {
    my ($test) = @_;
    assertNoOp($test < 50);
    return $test; 
}

## -- OR ------------------------------------------------------------

# Plain Or assertions

sub OrAssert {
    my ($test) = @_;
    ($test < 50) || die "Test is wrong";
    return $test;
}

# Or assertion with a handler

sub errorHandler {
    my $message = shift;
    die $message;
}

sub OrAssertHandler {
    my ($test) = @_;
    ($test < 50) || errorHandler("Test is wrong");
    return $test;
}

# Or assertion with no-op handler (turned off)

sub NoOpErrorHandler {} 

sub OrAssertHandlerNoOp {
    my ($test) = @_;
    ($test < 50) || NoOpErrorHandler("Test is wrong");
    return $test;
}

## -- test ----------------------------------------------------------

my @nums = map { ((rand() * 100) % 50) } (0 .. 100);

print(("-" x 80) . "\n");
print "Testing raw OR against sub\n";
print(("-" x 80) . "\n");

cmpthese(10_000, {    
    'SubAssert' => sub { eval { SubAssert($_) } for (@nums) },    
    'OrAssert'  => sub { eval { OrAssert($_)  } for (@nums) },   
});

print(("-" x 80) . "\n");
print "Testing with OR Error Handler and raw sub\n";
print(("-" x 80) . "\n");

cmpthese(10_000, {    
    'SubAssert'        => sub { eval { SubAssert($_)        } for (@nums) },    
    'OrAssertHandler'  => sub { eval { OrAssertHandler($_)  } for (@nums) },   
});

print(("-" x 80) . "\n");
print "Testing with no-op OR Error Handler and no-op sub (assertions off)\n";
print(("-" x 80) . "\n");

cmpthese(10_000, {    
    'SubAssertNoOp'       => sub { eval { SubAssertNoOp($_)       } for (@nums) },    
    'OrAssertHandlerNoOp' => sub { eval { OrAssertHandlerNoOp($_) } for (@nums) },   
});

##</code><code>##

--------------------------------------------------------------------------------
Testing raw OR against sub
--------------------------------------------------------------------------------
Benchmark: timing 10000 iterations of OrAssert, SubAssert...
  OrAssert:  8 wallclock secs ( 7.20 usr +  0.00 sys =  7.20 CPU) @ 1388.89/s (n=10000)
 SubAssert: 11 wallclock secs (10.83 usr +  0.07 sys = 10.90 CPU) @ 917.43/s (n=10000)
            Rate SubAssert  OrAssert
SubAssert  917/s        --      -34%
OrAssert  1389/s       51%        --
--------------------------------------------------------------------------------
Testing with OR Error Handler and raw sub
--------------------------------------------------------------------------------
Benchmark: timing 10000 iterations of OrAssertHandler, SubAssert...
OrAssertHandler:  7 wallclock secs ( 7.12 usr +  0.06 sys =  7.18 CPU) @ 1392.76/s (n=10000)
 SubAssert: 12 wallclock secs (10.56 usr +  0.12 sys = 10.68 CPU) @ 936.33/s (n=10000)
                  Rate       SubAssert OrAssertHandler
SubAssert        936/s              --            -33%
OrAssertHandler 1393/s             49%              --
--------------------------------------------------------------------------------
Testing with no-op OR Error Handler and no-op sub (assertions off)
--------------------------------------------------------------------------------
Benchmark: timing 10000 iterations of OrAssertHandlerNoOp, SubAssertNoOp...
OrAssertHandlerNoOp:  8 wallclock secs ( 7.18 usr +  0.04 sys =  7.22 CPU) @ 1385.04/s (n=10000)
SubAssertNoOp: 10 wallclock secs ( 9.17 usr +  0.02 sys =  9.19 CPU) @ 1088.14/s (n=10000)
                      Rate       SubAssertNoOp OrAssertHandlerNoOp
SubAssertNoOp       1088/s                  --                -21%
OrAssertHandlerNoOp 1385/s                 27%                  --