while (my $a = shift @a) {
[download]

If you're really intent on squeezing the assignment into the while loop, try:

while ( (my $a, @a) = @a ) {
[download]

In this case, I wouldn't actually use it since it reassigns most of @a to itself every time and is very inefficient in that respect.

Or use the comma operator: while (@a and my $a = shift @a, 1) { ... }

(Updated code is in bold)

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart

In reply to blokhead, you're absolutely right about the potential early termination.  And of course, it becomes essential when reading in a file, which could contain blank lines, that instead of:

while ($line = <$fh>) {
    # ...
}
[download]

you do something like:

while (defined($line = <$fh>)) {
    # ...
}
[download]

But then, when I looked more carefully at the idiom you suggested, there's a subtle bug in:  while ( (my $a, @a) = @a ) {".  I realized it doesn't, in fact, reasign most of @a to iteslf every time, because you're declaring my @a (along with my $a), so it's a different @a that you're doing the assignment to!  Also, when you run it, you get an infinite loop:

my @a = qw( 1 2 3 4 5 );

while (my ($a, @a) = shift @a) {
    printf "Next value = $a\n";
    printf "Size of \@a = %d\n", 0 + @a;
}

# When run ... infinite loop!
# (Note that "Size of @a" shows the temporary @a, not the original)
Next value = 1
Size of @a = 0
Next value = 2
Size of @a = 0
Next value = 3
Size of @a = 0
Next value = 4
Size of @a = 0
Next value = 5
Size of @a = 0
Next value =
Size of @a = 0
Next value =
Size of @a = 0
Next value =
[download]

And japhy, you've got an interesting idiom too, but it also doesn't do quite what you want, because the ",1" makes the expression eternally true, so you also get an infinite loop even after @a is exhausted.  So for now, I'll stick with the "while (defined($a = shift @a))" syntax.

As mentioned by others, that will fail if the array may contain false or undefined values. You can do something similar by keeping the entire assignment in list context and making sure to assign a list:

while( my ( $a ) = @a ? shift @a : () ) {
    # ...
}
[download]

Note the parens around $a: they make all the difference. They put the my (and thus the entire expression) in list context, and so the boolean value depends on the number of elements assigned. The ternary operator contortion on the right side ensures that when @a is empty, an empty list is assigned, so the loop aborts correctly.

Try putting empty strings, zeros or undefs in the array: you’ll find it will always do exactly what it’s supposed to.

However, elegant is not what it is. I’d much rather use while( @a ) and do a separate shift – far fewer subtleties to contend with.

Makeshifts last the longest.