What's the best way to conditionally include an element in a list?

Question

Possible ways:

1. Using push:

   my @list;  
   push @list, 'foo' if $foo;  
   push @list, 'bar' if $bar;  
   

2. Using the conditional operator:

   my @list = (  
       $foo ? 'foo' : (),    
       $bar ? 'bar' : (),              
   );
   

3. Using the x!! Boolean list squash operator:

   my @list = (  
       ('foo') x!! $foo,  
       ('bar') x!! $bar,  
   );  
   

Which one is better and why?

Answer 1

I'd like to suggest what I shall dub the "Readable" approach:

sub maybe ($$) { $_[1] ? $_[0] : () }

my @list = (
  maybe("foo", $foo),
  maybe("bar", $bar),
);

It has many of the benefits of this alleged x!! operator (though slightly longer), but with the added bonus that you can actually understand your code when you come back to it later.

EDIT: The prototype doesn't help Perl parse any better and doesn't let us ditch the parenthesis, it just prevents Perl from doing things we don't want. If we want to ditch the parens, we have to do some work. Here's an alternate version that works without parenthesis:

sub maybe {
  my($var, $cond, @rest) = @_;
  return @rest unless $cond;
  return $var, @rest;
}

my @list = (
  maybe "foo", $foo,
  maybe "bar", $bar,
);

No matter what we do with prototypes, Perl will try to parse it as maybe("foo", $foo, maybe("bar", $bar)), so if we want to ditch the parenthesis, we just have to make that give the correct result.

Answer 2

Personally I use $foo ? 'foo' : () in such cases, since it is clear (comparing to ('foo') x!! $foo), doesn't require particular effort to be understood (comparing to ('foo') x !!$foo) and can be used in the list context (comparing to push @list, 'foo' if $foo;).

But, of course, the answer depends on what criteria you choose to choose the best option. If you compare them by obfuscation, ('foo') x!! $foo will surely win. If you compare them by clumsiness, push @list, 'foo' if $foo; will be the first. Or maybe you meant performance? I guess not :-)

But if you compare them by good style, my choice is $foo ? 'foo' : ().

Answer 3

Although the OP didn't call for it, this problem provided me with a good excuse to use Benchmark;

Here's the code:

use strict;
use warnings;
use Benchmark qw( cmpthese);

my $foo = 1;
my $bar = "true";

cmpthese( -10, {
  "push" => sub {
      my @list;
      push @list, 'foo' if $foo;
      push @list, 'bar' if $bar;
  },
  "?::" => sub {
      my @list = (
        $foo ? 'foo' : (),
        $bar ? 'bar' : ()
      );
  },
  "x!!" => sub {
      my @list = (
        ('foo') x!! $foo,
        ('bar') x!! $bar
      );
  }
});

---

And here are some typical results:

         Rate  x!!  ?:: push
x!!  646539/s   --  -8% -12%
?::  701429/s   8%   --  -5%
push 736035/s  14%   5%   --

---

Given brian d foy's 7% estimate for Benchmark's uncertainty, it definitely seems like push is the fastest way to grow.

Summing up:

$need4speed ? do { push @like $this} : try { something('less' x!! $obfuscated) };
# DISCLAIMER: This is not valid code