sub f0 {
    my ($arg) = grep length, shift, 'default';
    $arg;
}
[download]

        Rate stupid   golf simple
stupid 250/s     --   -13%   -39%
golf   286/s    15%     --   -30%
simple 411/s    65%    44%     --
[download]

a) are the -s and -l switches necessary?

They are in every script I write, unless the function of the script requires their removal to operate properly; which is a very rare occurrence.

1. The -l so I don't have to litter my code with  . "\n"; or equivalent.
2. The -s so that if I want to add some simple parameterisations. Eg.

   #! perl -slw
   use strict;
   use Benchmark qw[ cmpthese ];
   
   sub f1 { # ( [$:arg] )
       use 5.007003; # perl v5.7.3; required for List::Util to be availab
   +le in CORE
       use List::Util qw/ first /;
       my $arg = first { defined && length } ( shift, 'default_value' );
       $arg;
   }
   
   sub f2 {
       my $arg = defined $_[0] && length $_[0] ? shift : 'default';
       $arg;
   }
   
   our $ITERS //= 1000;
   our @args = ( undef, '', 'fred', 1, 1.5 ) x $ITERS;
   
   cmpthese -1, {
       stupid => q[ f1( $_ ) for @args ],
       simple => q[ f2( $_ ) for @args ],
   }
   
   __END__
   C:\test>junk0 -ITERS=10000
            Rate stupid simple
   stupid 12.8/s     --   -58%
   simple 30.2/s   136%     --
   [download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I knew I was on the right track :)

In the absence of evidence, opinion is indistinguishable from prejudice.

Ah, thank you. Time to reread perlrun, as I had only thought about -l's input side...

You are doing enough work as you have missed the test for defined'ness.

It's not needed, but changing the context to scalar is:

#!/usr/bin/perl
use warnings;
use strict;
use Syntax::Construct qw( // );

use Benchmark qw{ cmpthese };
use List::Util qw{ first };
use Test::More;

sub f0 {
    my ($arg) = grep length, shift, 'default';
    $arg
}

sub f1 {
    my $arg = first { defined && length } shift, 'default';
    $arg
}

sub f2 {
    my $arg = defined $_[0] && length $_[0] ? shift : 'default';
    $arg
}

our @args = ( undef, '', 'fred', 1, 1.5 ) x 1000;

for my $arg (@args[ 0 .. 4 ]) {
    is f0($arg), f1($arg), "f0-f1-" . ($arg // 'undef');
    is f0($arg), f2($arg), "f0-f2-" . ($arg // 'undef');
}
done_testing();

cmpthese -1, {
    grep   => q[ f0( $_ ) for @args ],
    first  => q[ f1( $_ ) for @args ],
    simple => q[ f2( $_ ) for @args ],
};
[download]

ok 1 - f0-f1-undef
ok 2 - f0-f2-undef
ok 3 - f0-f1-
ok 4 - f0-f2-
ok 5 - f0-f1-fred
ok 6 - f0-f2-fred
ok 7 - f0-f1-1
ok 8 - f0-f2-1
ok 9 - f0-f1-1.5
ok 10 - f0-f2-1.5
1..10
         Rate  first   grep simple
first   570/s     --   -14%   -45%
grep    661/s    16%     --   -36%
simple 1036/s    82%    57%     --
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

As choroba wrote, it is not needed. Analyzed from right to left, it constructs a two-element-list of the (possibly undefined) argument and the default value. Grep applies the length function and filters the list according to that. We take the first element of grep's result.

Edge cases:
• length undef → undef (boolean false)
• length '' → 0 (boolean false)
• length 0 → 1 (boolean true)
Thus we'll skip an undefined or empty argument, just as desired by OP. Efficiency is only medium, because list construction and grep are more work than one or two single tests.

(Dang it!) I meant to write: You are NOT doing enough work as you have missed the test for defined'ness.

@BrowserUk,

Well, from your choice of function names, I see you have a strong negative opinion about the choice. I, respectfully, disagree.

Firstly, your f2() solution is great and on target. But, I'm a language polyglot, using perl to a moderate extent... not an expert, by far. And to me, the f1() version using List::Util is easier to read and understand at a glance. I also like that it doesn't have an extra visible temporary variable, not for performance reasons, but to minimize the chance for error when reusing the idiom.

Your performance argument, while well proven and valid from the viewpoint of that single line, doesn't hold up when looking at the use of the function or script as a whole. It's a premature optimization. There is literally no perceptible (or even measurable) difference in the script execution performance between any of the solutions presented. It's fun to analyze and debate. But, until I see some sort of real performance bottleneck by the function using this idiom during some actual use, I'm leaning to the side of easier comprehension (again, for me).

But, thank you, for applying your brain power to this... as always, I enjoy reading and learning from your comments.