#!/usr/bin/perl

use strict;
use warnings;

my $n = 9;
my @list = (1..$n);

my $list = @list;

print @list, "\n";
print $list, "\n";
[download]

#!/usr/bin/perl

use strict;
use warnings;

$. = 1;
my $n = 9;
my $list = (1..$n);
[download]

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).

#!/usr/bin/perl

use strict;
use warnings;

my $m = 1;
my $n = 9;
my $list = ($m..$n);
[download]

But what does $list contain? If I print it I get 1E0.

---

Perl is Huffman encoded by design.

From perlop:



The value returned is either the empty string for false, or a sequence number (beginning with 1) for true. The sequence number is reset for each range encountered. The final sequence number in a range has the string "E0" appended to it, which doesn't affect its numeric value, but gives you something to search for if you want to exclude the endpoint. You can exclude the beginning point by waiting for the sequence number to be greater than 1.



The range operator has always stumped me a bit, so I can't say much more than what it says above

Update: I suppose it is working like this (in the case of setting $. to 1) - please correct me if I am wrong:

Since 1 is a constant, and so is $., it is evaluated as TRUE.
Since the LHS is true, the RHS is evaluated immediately.
Since the RHS is NOT a constant, it is not compared to $., but is returned as true because it is not false (i.e. 9 is not 0, "" or undef).
The range operation is completed.
Because it is a single iteration only, the sequence number is 1, and is appended with "E0"

I'm not sure where the (or flip) comes from, but the problem is that the code is trying to assign a list to a scalar. Here are versions that work:

use warnings;
use strict;

my $n = 9;
my $listRef = [(1..$n)]; # Assign array reference
my @list = (1..$n); # Assign to an array
[download]

Paladin has lucidly described the source of your error, but I notice there still seems to be some confusion about what the flip-flop operator actually does. Hopefully I can help clear the air a bit.

It's probably best to think of scalar .. and list .. as two completely different operators. You can sort of kind of see a connection between them, but what they do is different enough that it's confusing to think of both at once. I assume we all know what list .. does; it's the scalar version that is kind of confusing. But when you shake yourself free from the baggage of thinking about the range operator, it becomes a lot easier to understand.

The flip-flop is essentially a flag. It turns on, or off, depending on the two endpoints. The two endpoints are compared against something to determine whether or not to flip the flag on or off. If the first endpoint compares true, the flag is flipped on. If the second endpoint compares true, the flag is flipped off. This allows you to do some pretty useful things, such as get all the lines in a file between "BEGIN" and "END", or lines 2-24. Here are some (hopefully) clear examples:

my @lines = qw(foo BEGIN bar baz END qux);
for (@lines) {
  if (/BEGIN/ .. /END/) {
    print "$_\n";
  }
}

while (<DATA>) {
  if (3 .. 5) {
    print;
  }
}

__DATA__
Line one
Line two
The third
and fourth
what about the fifth?
or the sixth?
[download]

Yes, in fact, flipflop will be a different operator in Perl 6, or maybe even just a macro. (A range operator in scalar context will just produce a range object.) And with the advent of state variables the macro could be written entirely in terms of lower-level primitives.

Also, one of my pet peeves is that Perl doesn't even try to tell you which entity is generating the uninitialized value. Sometimes it's not so easy to find (either because of code complexity, or sheer mental obstruction).