Re^6: eval order of args to a sub

Mmm, that doesn't say what you think it says.

"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".

This answers the question "Which minus operator will be evaluated first?" But our question is different: "Will a given operator evaluate its left-hand or right-hand argument first?"

In other words, what if the code were foo() - bar() - baz()? Will foo() execute before bar(), or the reverse? Operator associativity has nothing to say about that. This is the same issue as $i++ * $i and foo($i++, $i).

I've looked through the docs, and it's not there. Perl doesn't define the evaluation order of subexpressions.

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

Replies are listed 'Best First'.
Re^7: eval order of args to a sub by ikegami (Patriarch) on Jun 03, 2007 at 15:00 UTC
So your saying that if operation evaluation order (associativity) is specified, but operand evaluation order is not specified, `$result = foo() - bar() - baz() - moo();` [download] could be evaluated as `$anon1 = moo(); $anon2 = baz(); $anon3 = bar(); $anon4 = foo(); $result = (($anon4 - $anon3) - $anon2) - $anon1;` [download] I suppose you're right and it doesn't violate the definition of associativity, but how odd!	[reply] [d/l] [select]
Re^8: eval order of args to a sub by shmem (Chancellor) on Jun 04, 2007 at 01:15 UTC
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. Read more... (2 kB) 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}	[reply] [d/l] [select]
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


more useful options
	PerlMonks