/* Loops: while, until, for, and a bare block */
loop    :       label WHILE '(' remember texpr ')' mintro mblock cont
                        { PL_copline = (line_t)$2;
                            $$ = block_end($4,
                                   newSTATEOP(0, $1,
                                     newWHILEOP(0, 1, (LOOP*)Nullop,
                                                $2, $5, $8, $9, $7)));
+ }
...
        |       label FOR '(' remember mnexpr ';' texpr ';' mintro mne
+xpr ')'
                    mblock
                        /* basically fake up an initialize-while lines
+eq */
                        { OP *forop;

                          PL_copline = (line_t)$2;
                          forop = newSTATEOP(0, $1,
                                            newWHILEOP(0, 1, (LOOP*)Nu
+llop,
                                                $2, scalar($7),
                                                $12, $10, $9));
                          if ($5) {
                                forop = append_elem(OP_LINESEQ,
                                        newSTATEOP(0, ($1?savepv($1):N
+ullch),
                                                   $5),
                                        forop);
                          }

                          $$ = block_end($4, forop); }
...
/* Boolean expression */
texpr   :       /* NULL means true */
                        { (void)scan_num("1", &yylval); $$ = yylval.op
+val; }
        |       expr
        ;
[download]

AIUI, while () would be illegal if it had said

loop    :       label WHILE '(' remember expr ')' mintro mblock cont
[download]

The code in ysth's post is completely definitive, of course, and can be further verified by using the Perl bytecode compiler (B::Bytecode). If you execute the following:

perl -MO=Bytecode,-H,-ofor_loop    -e 'for (;;) {}'
perl -MO=Bytecode,-H,-owhile_loop  -e 'while () {}'
perl -MO=Bytecode,-H,-owhile1_loop -e 'while (1) {}'
[download]

and then diff the resulting files (for_loop, while_loop and while1_loop), you will find that they are all completely identical. This means that all three are exactly equivalent as far as code execution goes.

Update: I didn't mean it's a very special case out of the set of cases where there is no expression; I meant that there being no expression is a very special case (that you can't mimic with any expression). The documentation specifies that while takes an expression.

I don't believe that while(()) is an example of no expression. Rather, while(()) evaluates the condition (), a list of no elements. A list evaluated in scalar conext yields the last element, according to man perldata:

If you evaluate an array in scalar context, it returns the length of the array. (Note that this is not true of lists, which return the last value, like the C comma operator, nor of built-in functions, which return whatever they feel like returning.)

What's the "last value" of an empty list? Experiments indicate that it's undef, a false value, so the while-loop doesn't loop.

FYI, the output of deparse (which gets it wrong, occasionally) is:

> perl  -MO=Deparse -e 'while () { print "..\n" }'
while (1) {
    print "..\n";
}
-e syntax OK
[download]

It's not contrary to that quote from perlsyn, because there is no expression to evaluate. That quote simply doesn't apply.

However, it is contrary to the perlsyn line that says "LABEL while (EXPR) BLOCK", without adding that EXPR is optional.

Indeed this is what calin himself found, but it seems to be version dependent too (with no substantial differences, however). See Re^3: Reopen file when contents changed?.

I now think that while () deparses as for because while (1) is "optimised" (whatever that means) into for(;;) in perl 5.6.1.

$ perl561 -MO=Deparse -e 'while(1) {1}'
for (;;) {
    '???';
}
[download]

It is quite interesting to see that sometimes mistyping can lead to unexpected discoveries in the language syntax...

Surprisingly, I couldn't find anything about this syntax in Perl or C on the Net... But from (working, heh) code, it seems that an empty condition is evaluated as true...

Here's what I found that might be related. It's from description of perl5db, the Perl debugger:

...

%postponed

Saves breakpoints for code that hasn't been compiled yet. Keys are sub
+routine names, values are:

    * compile - break when this sub is compiled
    * break +0 if <condition> - break (conditionally) at the start of 
+this routine. The condition will be '1' if no condition was specified
+.

...
[download]

It is quite interesting to see that sometimes mistyping can lead to unexpected discoveries in the language syntax...

Mind

Richard Wilbur

Mind in its purest play is like some bat
That beats about in caverns all alone,
Contriving by a kind of senseless wit
Not to conclude against a wall of stone.

It has no need to falter or explore;
Darkly it knows what obstacles are there,
And so may wave and flitter, dip and soar
In perfect courses through the blackest air.

And has this simile a like perfection?
The mind is like a bat. Precisely. Save
That in the very happiest intellection
A graceful error may correct the cave.

I think so too. However perlsyn suggest that it is C-style for which is really a while loop in disguise and not the other way round.

If for is really a while in disguise, maybe they allowed while to have a empty condition to create a simple transformation from for to while.

In other words, if

for (a; b; c) {
   d
}
[download]

is translated into

a;
while (b) {
   d
} continue {
   c
}
[download]

having the while accept an empty condition simplifies the translation.

By the way, C doesn't allow an empty while condition:
a.cpp:5: ANSI C++ forbids an empty condition for `while'

I agree. The phenomenon that for in perl is equivalent to while is best shown in that for(;<>;){ has the same magic as while(<>){.

Also I note that until(){ is accepted too, and it seems to mean until(1){, that is, it's not executed at all.

Of course, while() means while(1) only as a prefix while. A suffix while (); has an empty list in its condition as expected, so it doesn't execute at all, a suffix while; is an error, and the results for until is similar.