Re^8: eval order of args to a sub

Operation evaluation order is about precedence, operand evaluation order is about associativity, so your case won't happen.

+ - . have "left associativity", so the operands are evaluated in that order; after evaluating the operands for an operation each operation takes place in the order which satisfies said associativity.

perl -MO=Concise,-exec -le '$x = 10;
    for(qw(moo baz bar foo)) {
        *{$_} = sub { $x + shift };
        $x-=3;
    }
    $result = foo() - bar() - baz() - moo();print $result'
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v
3  <$> const[IV 10] s
4  <#> gvsv[*x] s
5  <2> sassign vKS/2
6  <;> nextstate(main 4 -e:1) v
7  <0> pushmark sM
8  <$> const[PV "moo"] sM
9  <$> const[PV "baz"] sM
a  <$> const[PV "bar"] sM
b  <$> const[PV "foo"] sM
c  <#> gv[*_] s
d  <{> enteriter(next->p last->s redo->e) lK
q  <0> iter s
r  <|> and(other->e) vK/1
e      <;> nextstate(main 3 -e:1) v
f      <0> pushmark sRM
g      <$> anoncode[CV ] lRM
h      <1> refgen sK/1
i      <#> gvsv[*_] s
j      <1> rv2gv sKRM*/1
k      <2> sassign vKS/2
l      <;> nextstate(main 3 -e:1) v
m      <#> gvsv[*x] s
n      <$> const[IV 3] s
o      <2> subtract[t5] vKS/2
p      <0> unstack v
           goto q
s  <2> leaveloop vK/2
t  <;> nextstate(main 5 -e:1) v
u  <0> pushmark s
v  <#> gv[*foo] s/EARLYCV
w  <1> entersub[t9] sKS/TARG,1
x  <0> pushmark s
y  <#> gv[*bar] s/EARLYCV
z  <1> entersub[t11] sKS/TARG,1
10 <2> subtract[t12] sK/2
11 <0> pushmark s
12 <#> gv[*baz] s/EARLYCV
13 <1> entersub[t14] sKS/TARG,1
14 <2> subtract[t15] sK/2
15 <0> pushmark s
16 <#> gv[*moo] s/EARLYCV
17 <1> entersub[t17] sKS/TARG,1
18 <2> subtract[t18] sK/2
19 <#> gvsv[*result] s
1a <2> sassign vKS/2
1b <;> nextstate(main 5 -e:1) v
1c <0> pushmark s
1d <#> gvsv[*result] s
1e <@> print vK
1f <@> leave[1 ref] vKP/REFC
-e syntax OK
[download]

The left associativity leads to the following order:

$result = ( ( foo() - bar() ) - baz() ) - moo();
[download]

which is also the order of execution of the subexpressions. Right from perlop:

Operator associativity defines what happens if a sequence of the same operators is used one after another: whether the evaluator will evaluate the left operations first or the right. For example, in "8 - 4 - 2", subtraction is left associative so Perl evaluates the expression left to right. "8 - 4" is evaluated first making the expression "4 - 2 == 2" and not "8 - 2 == 6".

which IMHO pretty well defines the execution order of subexpressions.

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Comment on Re^8: eval order of args to a sub Select or Download Code

Replies are listed 'Best First'.
Re^9: eval order of args to a sub by mrpeabody (Friar) on Jun 04, 2007 at 10:41 UTC
The debug output does demonstrate that, for a specific toy example run on your particular binary, foo() executes first. That's a long way from showing that Perl will behave similarly for all operators and all operands, including tied variables, slow system calls, and threaded applications. + - . have "left associativity", so the operands are evaluated in that order; after evaluating the operands for an operation each operation takes place in the order which satisfies said associativity. People might assume that, but it's just not on the page. The snippet we both quoted clearly confines itself to breaking operand-binding ties between adjacent identical operators. On the issue of when to evaluate each operand, the Camel speaketh not. For that matter, you don't even know for sure that foo() will always be evaluated before moo(). Perl could run those functions left-to-right, right-to-left, or all at the same time and still be within spec. It just has to apply the operators in a certain order and finish up before beginning the next statement.	[reply]
Re^9: eval order of args to a sub by ikegami (Patriarch) on Jun 04, 2007 at 13:38 UTC
Operation evaluation order is about precedence, operand evaluation order is about associativity Precedence is about the order of evaluation of different operators. Associativity is about the order of evaluation of operators with the same precedence. While associativity seems to imply operand evaluation order, that's just an unfounded assumption.	[reply]
Re^10: eval order of args to a sub by shmem (Chancellor) on Jun 05, 2007 at 09:49 UTC
You are both right, mrpeabody and ikegami - it's not in the specs; but my take on this is that in the expression `$result = 8 - 4 - 2;` [download] the term `8 - 4` is a subexpression and the operand for the rightmost substraction operation; from that I deduce that associativity therefore defines the operand and subexpression evaluation order. That might be a logical fallacy; which one, I wonder? Anyways, that's how perl does it, although it is not defined in Perl. Of course the implementation could change, and perl could do a breadth-first evaluation of its execution tree and roll a dice for ad-hoc definition of evaluation order. But the optimizer would set things straight again, I guess :-) --shmem _($_=" "x(1<<5)."?\n".q·/)Oo. G°\ / /\_¯/(q / ---------------------------- \__(m.====·.(_("always off the crowd"))."· ");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}	[reply] [d/l] [select]