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]

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]

Thanks choroba & soonix.

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.