That comma is the sequence operator in scalar context. As in C, the left hand argument is evaluated, then the right, unconditionally. The comma expression returns the value of the right hand argument.

Precedence causes the expressions in that statement to bind like this:     DO_SOMETHING or (warn("some warning"), next); If DO_SOMETHING evaluates false, the warning is issued and next is (uselessly, here) called.

The sequence operator is placed in scalar context by the logical or. In list context, the comma op evaluates and returns a list of both left and right values. That's familiar from providing arguments to subs and initializing arrays. The scalar comma can be thought of as similar to the '||' and '&&' logical ops, differing by the unconditional evaluation of the right hand argument.

It's the comma operator. In this case, the comma expression is evaluated in a scalar context (dictated by the or), but still each argument is evaluated; that's the intent here (i.e. the ultimate return value of the expression is not used). A more straightforward alternative for that line would be

if ( !DO_SOMETHING ) {
  warn("some warning");
  next;
}
[download]

unless ( DO_SOMETHING ) {
  warn("some warning");
  next;
}
[download]

yet another alternative using "do" so as to maintain the "reversed" syntax:

do { warn("some warning"); next } unless DO_SOMETHING;
[download]

%h=qw/a 1 b 0 c 2/;
while (($k,$v)=each %h) {
   $x=$v or warn("got a false value for key $k"),next;
#  $x=$v or warn "got a false value for key $k", next;
   print "got a true value for key $k: $v\n";
}
[download]

Apparently, when the parens are removed, the comma-separated things after "warn" are grouped and treated as args passed to warn -- and the second arg happens to be an expression that must be evaluated in order to pass the resulting value as an arg. But evaluation of "next" as the second arg has the effect of jumping directly to the next loop iteration -- so warn never gets called.

By putting parens around the single arg to "warn", you make sure that this expression is fully evaluated, and then the "next" expression is also evaluated, causing the jump to the next iteration. The comma binds tighter than "or", so the expressions separated by commas are evaluated as if they were a block relative to "or".

This will work:

$x=$v or (warn "got a false value for key $k"), next;
[download]

As it puts the precedence back to order.

One thing you need to know is the precedence between "or" and ",". Perl says "," has higer precedence. This is why "1 or warn("1"), warn("2")" does not print anything, otherwise, you would most likely see "2" gets printed.

That "next" appears to be decorative, unless that is not the last line in the loop as you showed.