I think the moral of the story is "understand what you are passing to your functions".

It appears that most ways that one might modify a variable in a function call will result in an alias to the variable being passed. Post-increment seems to be unique in that it creates an anonymous value.

C:\>perl -e "sub foo{ print join qq/\n/, map { \$_ .' - ' . $_ } @_ } 
+foo($i=1,++$i,$i++,$i+1,$i+=1,$i);
SCALAR(0x183059c) - 4
SCALAR(0x183059c) - 4
SCALAR(0x225f7c) - 2
SCALAR(0x18305fc) - 4
SCALAR(0x183059c) - 4
SCALAR(0x183059c) - 4
[download]

Post-increment seems to be unique in that it creates an anonymous value.

That doesn't suprise me. post-increment and post-decrement return (a copy of) the old value, while changing the original value. What I mean is, since post-*crement creates 2 values from one variable, you need a copy somewhere, and it makes sense (for ease of coding and performance - perl variables are passed by reference internally) to increment the original value and create a copy as the return value of the *crementation.
"What should it profit a man, if he should win a flame war, yet lose his cool?"

Absolutely, the post-*crement operators MUST create an anonymous value, so they do.

I wonder though, what the "expected" or "natural" behavior of the other constructs I posted should be.

Construct  Behavior  Expected
$i += 2    \$i       ???
$i++       Anon.     Anon.
$i + 1     Anon.     Anon.
$i++       Anon.     Anon.
++$i       \$i       Anon.
$i=2       \$i       ???
[download]

From reading the other posts here, I feel comfortable saying that people expect ++$i to pass an anonymous value. I'm not 100% sure what I'd expect the assignment operators (=, *=, etc) to pass. Since most langauges pass by value, I guess I'd expect the assignment operators to pass anonymous values equal to the value assigned to $i. For example for foo($i=2) my faulty intuition is that foo() would get an anonymous 2 in $_[0].


TGI says moo

Hmm.. now that I re-read that, it doesn't mean what I thought it meant.

As for the update: If the arguments were passed by value, and evaluated right-to-left, you'd expect a($i--,++$i) to pass (2,2)

"What should it profit a man, if he should win a flame war, yet lose his cool?"

You were looking at the wrong section of the document. If you check the Operator Precedence and Associativity table, you'll notice the list seperator is left-associative, and that operator associativity is defined as follows:

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.

I can confirm that is how it works on my system (ActivePerl 5.8.8 on WinXP).

I see. Thanks.

~dewey