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.

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.

He's referring to a quick "sketch" of code I had in a comment.

for (;;) {
   print("Enter Number: ");
   defined( my $line = <STDIN> )
      or last;
   s/^\s+//, s/\s+\z// for $line;
   next if $line eq '';
   last if $line =~ /^(?:d|done)\z/i;
   ...
}
[download]

as a replacement for

while ( (print "Enter Number: "), 
        (my $line=<STDIN>) !~ /^\s*d(?:one)?\s*$/i  
      )
{
   next if $line =~ /^\s*$/;  #re-prompt on blank lines
   ...
      chomp($line);
   ...
}
[download]