Foreach Loops

The "foreach" loop iterates over a normal list value and sets the variable VAR to be each element of the list in turn. If the variable is preceded with the keyword "my", then it is lexically scoped, and is therefore visible only within the loop. Otherwise, the variable is implicitly local to the loop and regains its former value upon exiting the loop. If the variable was previously declared with "my", it uses that variable instead of the global one, but it's still localized to the loop. This implicit localisation occurs only in a "foreach" loop.

$foo was bound to test() originally but then you slapped a localization over the binding so it was a separate variable being written to.

perl -le 'my $foo;print \$foo;for $foo(1){print \$foo}'
SCALAR(0x8152348)
SCALAR(0x81441c8)
[download]

Okay. That explains the code, but now begs the question, why is it so?

I can think of two or three situations where I would like to use a pre-declared loop variable in a for loop and have it retain it's value afterwards.

What I cannot think of, is any benefit for it not doing so, nor any major/common caveat that it avoids.

Is a pre-declared, lexical loop variable localized (something that you cannot ordinarially do) for the loop body duration, for a "least surprise" or other DWIM benefit? Or is it simple a side-effect or caveat of the implementation?

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail

A for loop and a foreach loop are slightly different. Adding to the confusion is that for and foreach are synonyms for each other (no pun intended).

for my $y ( @a ) {...}
[download]

makes $y an alias for one element of @a each time through the loop. Writing

foreach my $y ( @a ) {...}
[download]

is identical, but 4 chars longer to type.

On the other hand,

foreach ( $x=0; $x < $#a; $x++ ) {my $y=$a[$x];...}
[download]

would behave similarly, except $y is not an alias for elements of @a, but a copy. And using

for ( $x=0; $x < $#a; $x++ ) {my $y=$a[$x];...}
[download]

would not change the behavior here either.

Which form the compiler chooses is based on the argument list to for/foreach, and not the name itself!

I hope that helps :|

Update: I wish I'd have said it more like hv did below. Maybe he'll volunteer to edit for me in the future ;)

A for loop and a foreach loop are slightly different.

I attempted (but failed) to say that the OP seemed to understand them as different entities. The only difference is what follows the keyword, and not the keyword itself.

-QM
--
Quantum Mechanics: The dreams stuff is made of

I don't know why, I jsut know it is documented that way. I guess foreach could make a copy of the value for each element but I'd guess it'd be slow then.

I don't see why that would explain the behaiviour, as for localizes the variable lexically, just like local. That's probably so that you can use $_ implicitly even if it's the index variable of a for loop, for example print and print uc for hello prints helloHELLO.

This reply, however, has an answer to your question.

I haven't been able to think of a way of fixing this that isn't inefficient, otherwise I would probably have done it by now.

Dave.

Thanks for taking the time to explain it :)

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail

Thanks for explaining.

I thought that when perl localizes a variable (either with local or for) it just saves the old value of the variable somewhere (as an unnamed variable in the lexical evironment of the block in which you localize), and restores it on exit. (But it does the saving and restoring with an unwind-protect so that if an exception brings out perl from the block, the value gets restored.) I belive that implementation would not cause the faulty(?) behaiviour discussed here. I am still far from understanding perl internals, so that may be a bad solution (and slower).

As you cannot localize a my variable in perl (which might have some relation to how local is implemented), I cannot reproduce that "bug" with local instead of for.

Mit-scheme has the non-standard function (Update:) special form fluid-let, which is the equivalent of perl's local (let is that of my). With this, you can write

(let* ((v 2) (f (lambda () v))) (fluid-let ((v 5)) (f)))
[download]

This evaluates to 5, thus showing that f gets the new localized value of v. If you change fluid-let to let, you get 2 of course.

Update: This is of course just localization, not a for loop, which may be quite different. Because of the reason mentioned above, you can not translate this code to perl as is. If you use a global variable:

$v= 2; sub f {print $v} for $v (5) {f;}
[download]

or

$v= 2; sub f {print $v} {local $v= 5; f;}
[download]

you get 5 as expected. It is possible that foreach is of a different nature than local in perl.

The nub of the problem is that most people expect that in the following code,

my $x = 1;
sub foo { $x }
[download]

There is a single variable called $x which is accessible from the main program and from within foo. The way it happens to be implemented internally is that they are treated as two separate variables that happen to be initially aliased to the same value. Here's a little ASCII diagram.

Before the for loop; the two X's point to the same value

$MAIN_X  ---
            \
             -> +---+
$FOO_X  ------> | 1 |
                +---+
[download]

and during for $x (9) { ...

                +---+
$MAIN_X  -----> | 9 |
                +---+
              
                +---+
$FOO_X  ------> | 1 |
                +---+
[download]

So calling foo from within the loop causes the 1 to be printed, not the 9.

You are mostly right about how localization and for aliasing work, expect that its not entire values that are temporarily saved, it is simply a C pointer, either in the symbol table (eg local $x), in the scratchpad (eg my $x; for $x ()), or in an array or hash slot (eg local $h{foo}), that is pushed onto perl's savestack and replaced with a pointer to a different value.

Dave.