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]