while (expr1, expr2, expr3, expr4, expr5, expr6, expr7)

The ONLY time I use the comma operator is in the following way:

while ((print prompt), test-response-to-prompt)

How is this "opaque"?

My code prepends a single print statement in the "while", a very simple thing who's return value is ignored. Without the comma operator, I would have to prompt before the loop and then prompt before the next loop. This can lead to many prompt statements or calls to a prompt subroutine for each error condition instead of just "next;".

The print statement at the beginning has no effect upon the test-response-to-prompt code. Use of the comma operator avoids 2 or more other statements.

I avoid while(1) except in the case of servers. Those loops never exit. I consider your while(1) with multiple returns within the FOREVER statement (a typical #define for while (1)or for (;;)) to be confusing. You have to read the code to figure out what the "end of loop" condition really is.

I argue that it is better to put the "end of loop" condition in the "while" or "for" loop, right at the top rather than "burying it" within a FOREVER loop.

It is opaque for two reasons:

1/ because the comma operator is seldom used so little understood. I don't mean by you (or me even - I have occasionally used it in the past), but in general. (I know this because of the complaints I've received from co-workers when I've used them - "Are you allowed to do that!".)

2/ because the comma as operator is hard to see compared to how important its correct interpretation is to understanding the code. Most often commas are used in lists and tend to be treated as something the parser needs to do its job, but are essentially ignored by people reading the code - white space and layout are generally much better cues for understanding the form of the code.

Regardless of how a loop is structured you have to read the code to see how it terminates. I'd rather use a C/C++ do {...} while (...); construct than the while (1) {...} loop for this sort of problem where appropriate, but Perl doesn't provide that directly. In fact it's not appropriate in the code being discussed anyhow due to the print at the end of the loop.

Putting the termination test at the top of a loop is fine if you can do it. Where I used while (1) you can't provide a termination test because the information doesn't exist yet. However the exit conditions for the sub (and thus the loop) are very easy to see and the while (1) loop construct provides exactly the right signal - do it forever until something within the loop causes it to stop (disregarding someone putting an axe through the computer or other such event of course).

Using the comma operator to avoid a few statements is not a good argument unless it really does make the code clearer. In practise I don't recall a single case where using the comma operator made code clearer. I do however remember some nasty cases where it made the code less clear and introduced really hard to find bugs.

---

True laziness is hard work

It is opaque for two reasons: 1/ because the comma operator is seldom used so little understood. I don't mean by you (or me even - I have occasionally used it in the past), but in general. (I know this because of the complaints I've received from co-workers when I've used them - "Are you allowed to do that!".) 2/ because the comma as operator is hard to see compared to how important its correct interpretation is to understanding the code. Most often commas are used in lists and tend to be treated as something the parser needs to do its job, but are essentially ignored by people reading the code - white space and layout are generally much better cues for understanding the form of the code.

Well this code is nicely indented and has huge clues as to what is important or not.

while ( (print "Enter Number: "), 
        (my $line=<STDIN>) !~ /^\s*d(?:one)?\s*$/i  
      )
{....}
[download]

The above sort of statement is the single exception that I use the comma operator. I agree that indenting and spacing is one of the most important things that can be done when writing code.

In the above, maybe the reader or maintainer couldn't write this in the first place, but he/she will get the "gist" of the idea of what this while loop does.

Yes, the comma operator is rare. This is the only situation that I know of where it it justified. But "rare" does not mean "never".

I think my regex is fine. D,d,DOne,donE, etc match.

How is this "opaque"?

Information overload. Input, output, assignment and (negated) regex match all crammed where a simple condition is expected. And you don't even handle EOF cleanly!

Please post your code with a better way for us to see.