What kind of syntactic sugar is available in Perl to reduce code for l/rvalue operators vs. if statements?

Question

There's a bunch out there, as Perl is a pretty sugary language, but the most used statements in any language is the combination of if statements and setting values. I think I've found many of them, but there's still a few gaps. Ultimately, the goal would be to not have to write a variable name more than once:

Here's what I have so far:

$r ||= $s;          # $r = $s unless ($r);
$r //= $s;          # $r = $s unless (defined $r);
$r &&= $s;          # $r = $s if ($r);
$r = $c ? $s : $t;  # if ($c) { $r = $s } else { $r = $t }
$c ? $r : $s = $t;  # if ($c) { $r = $t } else { $s = $t }
$r = $s || $t;      # if ($s) { $r = $s } else { $r = $t }
$r = $s && $t;      # if ($s) { $r = $t } else { $r = $s = undef, 0, untrue, etc. }
$c and return $r;   # return $r if ($c);
$c or  return $r;   # return $r unless ($c);
$c and $r = $s;     # $r = $s if ($c);
@$r{qw(a b c d)}    # ($r->{a}, $r->{b}, $r->{c}, $r->{d})

Somebody also had a really interesting article on a "secret operator", shown here:

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

However, what I've found to be missing from the list is:

$r <= $s;                 # read as "$r = min($r, $s);" except with short-circuiting
$r = $s if (defined $s);  # what's the opposite of //?
$r and return $r          # can that be done without repeating $r?

Is there anything else worth adding? What other conditional set variables are available to reduce the code? What else is missing?

Answer 1

These structures from your question could be written a little bit more clearly using the low precedence and and or keywords:

$c and return $r;    # return $r if ($c);
$c or return $r;     # return $r unless ($c);
$c and $r = $s;      # $r = $s if ($c);

The nice thing about and and or is that unlike the statement modifier control words, and and or can be chained into compound expressions.

Another useful tool for syntactic sugar is using the for/foreach loop as a topicalizer over a single value. Consider the following:

$var = $new_value if defined $new_value;

vs

defined and $var = $_ for $new_value;

or things like:

$foo = "[$foo]";
$bar = "[$bar]";

$_ = "[$_]" for $foo, $bar;

the map function can also be used in this manner, and has a return value you can use.

Answer 2

There's also the left hand side ternary operator:

$cond ? $var1 : $var2 = "the value";

is equivalent to:

if ($cond) {
    $var1 = "the value";
} else {
    $var2 = "the value";
}

Answer 3

$r = $r < $s ? $r : $s;:

    $r = $s if $r > $s;

or

    use List::Util qw( min );

    $r = min($r, $s);

or:

    sub min_inplace {
       my $min_ref = \shift;
       for (@_) { $$min_ref = $_ if $$min_ref > $_; }
    }

    min_inplace($r, $s);

$r = $s if (defined $s);:

    $r = $s // $r;

$r = $t; $r = $s if (defined $s);:

    $r = $s // $t;

$r = !$s ? $s : $t;:

    $r = $s && $t;

Answer 4

One of the biggest called for features in Perl was the switch statement. This finally appeared in Perl 5.10. I'm just using the example from the documentation:

use feature qw(say switch);  #My preference
#use feature ":5.10";        #This does both "say" and "switch"

[...]

given($foo) {
    when (undef) {
        say '$foo is undefined';
    }
    when ("foo") {
        say '$foo is the string "foo"';
    }
    when ([1,3,5,7,9]) {
        say '$foo is an odd digit';
        continue; # Fall through
    }
    when ($_ < 100) {
        say '$foo is numerically less than 100';
    }
    when (\&complicated_check) {
        say 'a complicated check for $foo is true';
    }
    default {
        die q(I don't know what to do with $foo);
    }
}

Why o' why did they go with given/when and not switch/case like you find in most languages is a mystery to me. And, why if the statement is given/when, do you specify it in use features as switch?

Alas, the people who made these decisions are at a higher plane than I am, so I have no right to even question these luminaries.

---

I avoid the more exotic stuff, and stick with the easiest to understand syntax. Imagine the person who has to go through your code and find a bug of add a feature, which would be easier for that person to understand:

$r &&= $s;

or

if ($r) {
    $r = $s;
}

And, maybe I might realize that I really meant:

if (not defined $r) {
    $r = $s;
}

And, in this case, I might even say:

$r = $s if not defined $r;

Although I don't usually like post-fixed if statements because people tend to miss the if part when glancing through the code.

Perl is compiled at runtime, and the compiler is fairly efficient. So, even though it's way cooler to write $r &&= $s and it earns it earns you more geek points and is less to type, it doesn't execute any faster. The biggest amount of time spent on code is on maintaining it, so I'd rather skip the fancy stuff and go for readability.

By the way, when I think of syntactic sugar, I think of things added to the language to improve readability. A great example is the -> operator:

${${${$employee_ref}[0]}{phone}}[0];

vs.

$employee_ref->[0]->{phone}->[0];

Of course, if you're storing data as a reference to a list to a hash to a list, you are probably better off using object oriented coding.