If either operand of scalar ".." is a constant expression,
       that operand is considered true if it is equal ("==") to
       the current input line number (the $. variable).
[download]

Sigh. Thanks, apparently my RTFM skills are weak this morning.

...although, what do they mean by "constant expression?" Is $x ever a constant expression? What kind of expression doesn't "evaluate to a constant?"

my $x = 1;
for(1,2,3,4,5) 
{
  next  if $x..$x; # never returns true!
  print "$_\n";
}
[download]

You just demonstrated the difference between a 'constant value' and a 'constant expression'.

UPDATE: Arrrgh, again I fell into the trap of not reading thoroughly. Please ignore.

UPUPDATE: After testing more thoroughly, it seems that when something like $x is used instead of 1, something happens that is not consistent with the docs:

for(1,2,3,4,5) 
{
    $.= $_;
  next  if 1..1;
  print "$_\n";
}
#### prints as expected
2 3 4 5

my $x=1;
for(1,2,3,4,5) 
{
    $.= $_;
  next  if $x..$x; # never returns true!
  print "$_\n";
}
#### prints nothing. Why??? It doesn't test against $. and it doesn't 
+just test the value $x


my $x = 1;
my $y = 0;
for(1,2,3,4,5) 
{
    $.= $_;
  next  if $x..$y; # never returns true!
  print "$_ ";
}
#### prints nothing as well. If the flip and the flop happened at the 
+same round it would have printed something
[download]

Tried to run it with -Dx but that showed too much information. Wasn't there a debugging flag that shows just the compiled byte code?

UPUPUPDATE: corrected a copying mistake and explained the wrong output some more

while (<$fh>) {
   next if 1 .. 1;
   print "$_\n";
}
[download]

means

while (<$fh>) {
   next if $.==1 .. $.==1;
   print "$_\n";
}
[download]

so to do the same with a loop which counts over something other than $., you have specify it explicitly.

for (1,2,3,4,5) {
   next if $_==1 .. $_==1;
   print "$_\n";
}
[download]

what do they mean by "constant expression?"

Short: Anything that Perl converts to a constant at compile-time.

>perl -MO=Concise -e"print( 4 + 1 * 2 )"
6  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v ->3
5     <@> print vK ->6
3        <0> pushmark s ->4
4        <$> const[IV 6] s ->5           <--- 4+1*2
-e syntax OK

>perl -MO=Concise -e"print( 4 + $x * 2 )"
a  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v ->3
9     <@> print vK ->a
3        <0> pushmark s ->4
8        <2> add[t3] sK/2 ->9          \
4           <$> const[IV 4] s ->5      |
7           <2> multiply[t2] sK/2 ->8  | <--- 4+$x*2
-              <1> ex-rv2sv sK/1 ->6   |
5                 <#> gvsv[*x] s ->6   |
6              <$> const[IV 2] s ->7   /
[download]

Long: A constant expression is known to Perl to always return the same result. It includes constants (including those created by constant), most operators operating on constants, some builtin functions, and functions with the () prototype whose body consist entirely of a constant expression (as per Constant Functions in perlsub).

Given

sub PI() { 4 * atan2(1, 1) }
use constant SOMENUM => rand(4);
[download]

Example of constant expressions:

4
5+6*7
4 * atan2(1, 1)
PI
SOMENUM
[download]

...although, what do they mean by "constant expression?"

Yeah, good question. Constant expression means whatever perl constant-folds at compile time. Numeric and string literals are constant, most simple operators (arithmetic and logic and things like that, but not including x) are constant-folded iff all their arguments are constants, and so are a few named builtins like uc, most other expressions aren't. There are some corner cases (like the comma operator) and even some version differences, so if you want to know for sure what's constant-folded and what isn't, you may need to dump the code with use O "Deparse"; or even use O "Concise";. If in doubt, just compare to $. explicitly if you want that semantics.

There are at least two other cases where an expression being constant matters in how your perl code is interpretted, though one of these might be a bug: Twin-lines japh and Re^3: A cleaner way of scoping variables.

So what happens if $. is incremented appropriately in the loop? Does it magically start working?

Egads! It just worked!

(Add you own caveats here)

--
.sig : File not found.

Let me ask the question: what do you want?

next, if 1 .. 3; will only call next when the left condition is true until the right condition is true.

Written differently:

while (<>) {
  next, if 2 .. 5;
  print;
}
[download]

my $index = 0;
my $skip = 0;
while (<>) {
  $index++;
  if ($skip or $index == 2) {
    if ($index == 5) {
      $skip = 0;
    }
    next;
  }
  print;
}
[download]

If your code is looping over a sequence of numbers or if you are using another counter then you might be able to use: next if $_ == 2 .. $_ == 5;

I'm not asking how to accomplish something. I'm just examining the dark corners of a particular operator, trying to determine if there are any bugs or "accidental features" lurking there.

I would have sworn that next, if test wouldn't work, but it does. I can't understand why from the documentation of the comma operator, though—it seems like it should try to evaluate next, then if test (which is of course a syntax error), but that doesn't happen. Instead it seems to compile the same with or without the comma.

My take on it: The 'if' always follows a simple statement so the parser takes 'next,' as statement. Depending on context (in this case void?) this will be either a comma operator or a list with a dangling comma. It seems the comma operator also throws away dangling commas like a list:

> perl -e ' $d= (1,2); print "$d\n";'
2
> perl -e ' $d= (1,2,); print "$d\n";'
2
[download]