It's consistent with the documentation, which says a VAR is expected (with an optional my). $y[0] is an expression, not a variable. I suppose it could be considered a limitation, but not a bug.

The following can be used. If you want to next an arbitrary number of loops, check out Algorithm::Loops.

foreach $y0 (@x) {
  foreach $y1 (@x) { 
    do_something($y0, $y1);
  }
}
[download]

It's consistent with the documentation, which says a VAR is expected (with an optional my).

It should be pointed out that if the variable is already declared lexical in an enclosing scope then the my is assumed. i.e. it is not the previously declared lexical that is used but a different one.

IMNSHO perl should throw a warning when it infers an implicit my.

OK, that explains why. I must use simple scalar variables (or the default $_) as a for/foreach iterator. Thanks.

I have to admit - I've never thought about doing this ... but I can see how that would be some really nice-tasting syntactic sugar.... I would normally look at it this way:

#! user/bin/perl
use warnings;
use strict;

my @x = ( [1,1], [2,2], [3,3] );

sub do_something {}

# so, I use this method instead
foreach my $a1 (@x) {
  foreach my $a2 (@x) {
    do_something($a1, $a2);
  }
}
[download]

But maybe that's just me thinking "inside the box" again.

Yes, that too was my first thought. But, I actually had 10 nested foreach loops, and the programmer inside said "sounds like an array", so I tried to use elements of an array as the iterators. As always, TMTOWTDI.

I actually had 10 nested foreach loops, and the programmer inside said "sounds like an array"

The programmer inside me says "sounds like recursion".

Yes, you can't do that. Why would you want to? Ultimately what are you trying to accomplish? There's probably a better way.

use strict;

my @end =   ( 3, 3, 3 );
my @start = ( 0, 0, 0 );

my @index = @start;
LOOP: while (1)
{
    print "this is loop position [ @index ] \n";

    for my $q ( reverse 0 .. $#start )
    {
        $index[$q]++;
        last unless $index[$q] >= $end[$q];
        last LOOP unless $q;
        $index[$q] = $start[$q];
    }
}

print "done \n";
[download]

this is loop position [ 0 0 0 ] 
this is loop position [ 0 0 1 ] 
this is loop position [ 0 0 2 ] 
this is loop position [ 0 1 0 ] 
this is loop position [ 0 1 1 ] 
...........................
this is loop position [ 2 1 0 ] 
this is loop position [ 2 1 1 ] 
this is loop position [ 2 1 2 ] 
this is loop position [ 2 2 0 ] 
this is loop position [ 2 2 1 ] 
this is loop position [ 2 2 2 ] 
done
[download]

You can have it like this, with some syntactical constraints:

sub forache { for my $v (1..@_-2) { $_[0] = $_[$v]; &{$_[-1]}(); } } 
my $k; forache $k, ("greetings, ", "all\n"), sub{ print $k; }; 
my @a = ("hello, ", "<name>", "\n"); forache $a[1], ("james", "andy", 
+"bob", "david"), sub { print @a; };
[download]

I think it's by design. Foreach aliases the variable. This limitation is so that you can't easily create arrays with aliased elements, or people would end up with modifying an array element and wondering why an other array has changed. People would keep asking why that happens.

Update: Let me meake this clearer. You can have array elements aliased to each other like this.

@y = ("this", "that"); *x = &{sub {\@_}}(@y[reverse 0..@y-1], "your");
+ 
print "@x\n"; # ==> that this your
$y[0] = "great"; # I change @y
print "@x\n"; # ==> that great your
# hey, why did @x change, I didn't do anything with @x!
[download]