This is assuming that func() doesn't have any side-effects against its parameters.

$var = func($var) || $var;
[download]

davido has the answer. That's the way to do it. If func returns 0 or undef, $var will be assigned to $var, therefore keeping its original value. I use this technique all the time.

A for will get you from A to Z; a while will get you everywhere.

-- greengaroo

$cough ||= cough( $cough );

sub func {
    my $arg = shift;
    die 'Invalid Argument' if $arg > 10;
    return $arg - 2;
}

eval { $var = func($var) }; # No exception catching.
print "$var.\n";
[download]

Another possibility might be to change the function to return two values: the result and success. Upon failure, the result would be the same as the input argument, but the success would be 0. Otherwise, the function would return the new result and 1:

sub func {
    my $arg = shift;
    return($arg, 0) if $arg > 10;
    return($arg - 2, 1);
}

my $var = 10;
($var, my $succ) = func($var);
print "$var.\n";
[download]

Update: For numeric return values, you can just add a string to the number to indicate failure:

sub func {
    my $arg = shift;
    return $arg . 'E0' if $arg > 10;
    return $arg - 2;
}
[download]

See Range Operators for a similar trick.

nice list, but why not changing the argument alias in place to only return the error code?

  DB<101>  $var=2
 => 2

  DB<102> sub func {
               if ( $_[0] > 0 ) {
                  $_[0]--;
                  return OK_CODE;
               } 
               return ERR_CODE;
           } 

  DB<103> $err = func ($var);
 => "OK_CODE"

  DB<104> $err = func ($var);
 => "OK_CODE"

  DB<105> $err = func ($var);
 => "ERR_CODE"
[download]

Cheers Rolf

( addicted to the Perl Programming Language)

I think changing the sub to return $var in event of it being unable to complete its intended purpose would be the best option.

I don't like it but if changing the sub can't be done then this is the most consice method I could think of.

use strict;
use warnings;

my $var = 'foo';

my $tmp;
$var = ( $tmp = return_false() ) ? $tmp : $var;

print "$var\n";

$var = ( $tmp = return_true() ) ? $tmp : $var;

print "$var\n";


sub return_true
{
    return 'bar';
}

sub return_false
{
    return;
}
[download]

It is arguably more readable to save off the old value, and re-instate it if func returns undef/zero:

my $oldval;

$val = func( $oldval=$val) || $oldval;
[download]

Newer perl's allow the alternative of using the // (defined or) operator.

To maintain the challange of "not creating a new variable", one could try:

  $val = func( $_=$val) || $_;
[download]

Add a BLOCK, if $_ is being abused:

    $val = do{ func( local $_=$val) || $_ };
[download]

             When in doubt, mumble; when in trouble, delegate; when in charge, ponder. -- James H. Boren