The ||= only gets one shot to evaluate the left side and since it needs a boolean, it does it in scalar context. The context of the right hand side is determined by the left side so foo() is scalar too.

You really ought to update your node title though. It's misleading. The central question is about context and you'd want to use a title like "Why are "(a) || b" and "(a) = a || b" different."

Hmm, not sure I understand the 'one shot' part.

Wouldn't it be simpler to unravel

    my($ret) ||= foo();
[download]

to

    my($ret) = $ret || foo();
[download]

and process it accordingly? The way it's implemented now is really confusing to the user.

Hi saintmike,

diotalevi's perfectly right.

Look at it this way:

my($ret) ||= foo();
[download]

What you're doing amounts to this, step-wise:

1.  my ($ret);       # Create a scalar variable called $ret
2.  $ret ||= foo()   # If $ret is undefined or zero, assign it to foo(
+)
[download]

But of COURSE $ret is undefined when you first declare it, because you haven't assigned it to anything!

A similarly bad thing is going on here:

my($ret) = $ret || foo();
[download]

where you're trying to create a new scalar variable my($ret), but its value depends on a previously defined scalar called $ret (notice that's the same variable name?), or foo() if the the value of the $ret was previously undefined or zero.

If you use strict and warnings (as you always should), then you'll get an error with the second one.  Try this (essentially equivalent) code:

use strict;
use warnings;

my $x = $x || 5;
print "Now x = $x\n";
[download]

Without strict and warnings you get:

Now x = 5
[download]

but with them you get:

Global symbol "$x" requires explicit package name at test.pl line 5.
Execution of test.pl aborted due to compilation errors.
[download]

Finally, the reason your title is misleading (as diotalevi suggests), is because it's perfectly fine to do either:

use strict;
use warnings;

my $y = 7;
my $x;

$x = $x || $y;
print "Now x = $x\n";
[download]

and:

use strict;
use warnings;

my $y = 7;
my $x;

$x ||= $y;
print "Now x = $x\n";
[download]

which will both yield the expected:

Now x = 7
[download]

---

s''(q.S:$/9=(T1';s;(..)(..);$..=substr+crypt($1,$2),2,3;eg;print$..$/

No, it would not be simpler to change (a) ||= foo() to (a) = a || foo. I call your attention to Chapter 10 of On Lisp about pitfalls in macros as reference material and in particular, the part about Number of Evaluations. While you originally wrote (a) as your left hand expression, it could have been something else like bar() or (rand < .5 ? $a : $b). If you executed the left hand side multiple times, you could have inconsistent results.

# (a) could change entirely if run multiple times
( rand < .5 ? $a : $b ) = ( rand < .5 ? $a : $b );

# (a) might have side effects
bar() = bar() || foo();
sub bar :lvalue { ... }

# (a) might have side effects
tie $a, ...;
($a) = $a || foo();
[download]

In all those cases it would be an error to cause the single mention of (a) to expand to multiple mentions. Internally perl evaluates your (a) once. It uses the expression's value as the input to the || operator and then it uses the same already computed expression as an lvalue. To see this under the hood and why, use the B::Concise module to look at your program's structure. Get Idealized optrees from B::Concise to see a simpler view. I annotated the ouput by hand.

perl -MO=Concise -e '($a) ||= foo()' | idealized-optree

leave
   enter
   nextstate
      orassign # ||=
         gvsv    # << $a
         sassign # scalar =
            entersub # foo()
                  pushmark
                     gv # *foo
[download]

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

I think it matters when $ret is a tied variable and there is some sort of side effect when it is read. The ||= version only evaluates it once, I believe. Esoteric? Yes.

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

you'd want to use a title like "Why are "(a) || b" and "(a) = a || b" different."

I guess you mean

Why are "(a) ||= b" and "(a) = a || b" different

and you're right that it's slightly misleading, but I could argue that "a" is a place holder that can hold anything including (a) :).

It turns out that your assumption is not correct. In both scenarios foo() result is used in list context. This snippet of code will demonstrate it:

#!/usr/bin/perl -w
use strict;

sub foo {
   return (10,11,12,13);
}

my $ret = 0;
my $ret2= 0;
# EXPRESSION A
($ret,$ret2)||= foo();
print "ret=$ret  ret2=$ret2\n";
# ret2 returns 13, last element of list
# ret remains unused  (warning raised)

$ret=0;
# EXPRESSION B
($ret) = ($ret) || foo();
print "ret=$ret\n";
# returns 10,  first element of list
[download]

What drives the whole problem (and solution) is that the '||' operator returns the last value evaluated. And that's where the catch is!
Expression A evaluates the last element of ($ret,$ret2) against the last element of what foo() returns. Since what is listed on the lefthand of the '=' is part of the expression, only the last element of the left-hand operand gets updated.
In Expression B first Perl evaluates the expression on the righthand of the '='. The last values of the (righthand) operands are compared and because $ret is zero this option is discarded and the next operand, foo() is taken. So the result of the expression is foo's list (yes, all elements!). Subsequently this result gets assigned to what is on the lefthand of the '='.

All this shows that it can be tricky to use the '||' operator in a list context. The net result is not obvious and probably one wants to surround any such expression with a little bit of inline documentation so ease code maintenance. Frankly, for myself I would stay away from the construct where possible (except maybe in a nice JAPH).

Update: 'YAPH'=~s/Y/J/

To verify whether a function is called in list context or scalar context, use wantarray.

Here's a snippet of code to verify my assumption:

my $a;

($a) = ($a) || foo();
($a) ||= foo();

sub foo {
    wantarray ? print("list\n") : print("scalar\n");
    return 0;
}
[download]

and it prints

list
scalar

It looks like there really is a difference in the calling context:

#!/usr/bin/perl

use Carp;

my $ret;

undef $ret;
($ret) ||= foo();
warn "ret is $ret";

undef $ret;
($ret) = $ret || foo();
warn "ret is $ret";

sub foo
{
  carp "Want " . (wantarray ? "array" : "scalar");
  (1,2);
}
[download]

outputs:

Want scalar at t3 line 17
        main::foo() called at t3 line 8
ret is 2 at t3 line 9.
Want array at t3 line 17
        main::foo() called at t3 line 12
ret is 1 at t3 line 13.
[download]


--
sgifford's Web page

void is false

my $w = wantarray;
$w = defined $w ? ($w ? 'list' : 'scalar') : 'void';
carp "wantarray : $w ";
[download]

JAPH not YAPH

You could just say $ret ||= (foo())[0]; instead.

The equivalent would actually be

$ret ||= (foo())[-1];
[download]

I'm affraid no.

sub foo { 
        wantarray or 
                die "this function is called in list context in all ex
+amples"; 
        "alpha", "beta", "gamma"; 
} 
$ret = undef; 
($ret) = $ret || foo(); 
print "parenthetical: $ret\n";
$ret = undef; 
$ret ||= (foo())[0]; 
print "zero: $ret\n";
$ret = undef; 
$ret = (foo())[-1]; 
print "minus one: $ret\n";
[download]

Gives

parenthetical: alpha
zero: alpha
minus one: gamma
[download]