1. The ugly push-based version:

   my   @part = ( 'http://example.net/app' );
   push @part, 'admin'  if $is_admin_link;
   push @part, $subsite if defined $subsite;
   push @part, $mode;
   push @part, $id      if defined $id;
   push @part, $submode if defined $submode;
   
   my $uri = join '/', @parts;
   [download]

2. The nicer approach with a ternary:

   # [updated: originally had `'admin' ? $is_admin_link : ()`]
   
   my @part = (
       'http://example.net/app',
       ( $is_admin_link   ? 'admin'  : () ),
       ( defined $subsite ? $subsite : () ),
       $mode,
       ( defined $id      ? $id      : () ),
       ( defined $submode ? $submode : () ),
   );
   
   my $uri = join '/', @part;
   [download]

But both approaches require you to repeat yourself unncessarily. In the push case, you have to repeat the push @part bit, and in the ternary case, you have to supply : () as an else clause for every case.

Enter x!!

Obviously, this is a composite operator, consisting of x and two ! negations.

The double negation is there to forcibly convert the right side to a boolean value with the same truthness as the original value:

$a = undef;
print $a ? 'true' : 'false';  # prints 'false'
print $a;                     # prints '' and warns
$a = 0;
print $a ? 'true' : 'false';  # prints 'false'
print $a;                     # prints '0'
$a = 'abc';
print $a ? 'true' : 'false';  # prints 'true'
print $a;                     # prints 'abc'

# whereas

$a = undef;
print !!$a ? 'true' : 'false';  # prints 'false'
print !!$a;                     # prints '' without warning
$a = 0;
print !!$a ? 'true' : 'false';  # prints 'false'
print !!$a;                     # prints ''
$a = 'abc';
print !!$a ? 'true' : 'false';  # prints 'true'
print !!$a;                     # prints 1
[download]

So the !! will force anything that shows up on the right side to be either 1 or !1.

The x is, of course, Perl’s repetition operator:

@_ = ( 'a' ) x 4;
print join ':', @_;  # prints 'a:a:a:a'
print scalar @_;     # prints '4'
[download]

Of interest to us are the cases where the number of repetitions is 1 or 0:

@_ = ( 'a' ) x 1;
print join ':', @_;  # prints 'a'
print scalar @_;     # prints '1'

@_ = ( 'a' ) x 0;
print join ':', @_;  # prints ''
print scalar @_;     # prints '0'
[download]

Since boolean values in Perl are either 1 or !1, that means ( $something ) x $boolean will do exactly what we want. And we can force everything to be a boolean using the !! double negative. That is how we get x!!.

Bottom line: the example I gave can be written like this:

my @part = (
    'http://example.net/app',
    ( 'admin'  ) x!! $is_admin_link,
    ( $subsite ) x!! defined $subsite,
    $mode,
    ( $id      ) x!! defined $id,
    ( $submode ) x!! defined $submode,
);

my $uri = join '/', @parts;
[download]

Neato! Not only is it nicer, but I also find that x!! has a beautifully evocative quality. :-)

Conventional notes

You’ll notice that defined always returns a boolean anyway, so the !! isn’t actually necessary in three of our cases, and might not be necessary in the first one either.

However, I find that one should use x!! anyway, for two reasons:

1. It documents intent. Using x!! clearly signals that this is not just a repetition.
2. It protects you from errors. If the value of $is_admin_link is 2 for some reason, it is still true according to Perl, but in that case ( 'admin' ) x $is_admin_link (without !!) will yield a very different result from ( 'admin' ) x!! $is_admin_link (with !!).