Magic string auto-increment

At other times we use it to make lists of string or letters

for ('a' .. 'z') {
# $_ will start with the value 'a', then 'b' all the way up to 'z'
}
for ('aa' .. 'bb') {
# $_ will start with the value 'aa', then 'ab', then 'ac' up to
# 'az', then 'ba' and finally 'bb'
}

A bit of carefulness, though since it can bite you hard, just think what
would happen if we started with 'a' and then up to a user given
string? Imagine if it were 'zzzzzzzzz', the generated list is very
very long...

Scalar context

But the operator holds more power than this simple usage, for it can
also work wonders in scalar context.
Here it is a bistable boolean operator. What it means is that it is a
small state machine, which will return true or false depending on the
current conditions.

How it works

As any binary operator it takes two operands, the left and the
right. It starts by evaluating to false until the left operand becomes
true, thereafter it is true until the first iteration after the right
operand becomes true, where the state reverts back to false. And then
the cycle begins again.
Almost like the && operator, when in the false state, the right
operand is not evaluated and, reversed, when in the true state, the
left operand is not evaluated
One thing to notice is that when in the false state and the left
operand evaluates to true, it will also evaluate the right side in the
same operation, just like the && operator, but no matter if the right
side is true or false it will return true. If you want to wait until
next iteration with checking the right operand for the first time, you
can use the .. operators sibling, the ... operator.
An additional feature that we saw already in the first example is that
when the operands are constants, Perl will rewrite the code to
$. == constant. So that it checks the current line number
instead of just the constant.Examples
Not seldom I find myself having to have a loop variable which keeps
track of number of items I've seen within a range. In many cases
however I could just extract it from the .. operator, which also tells
me how many times it has currently matched.

while(<EMAIL>) {
my $body = /^$/ .. eof; #First blank line in email is start of body
my $header = 1 .. /^$/;
print "looking at line ",int$body," in the body\n" if $body;
print "looking at line ",int$header," in the header\n" if $header;
}

Looking for all the paragraphs, with individually enumerated lines in
a file? And we don't want the trailing blank line. For that we can use
the fact that it returns a "nnnE0" string instead of just the number.

I think perlop might do a better
job explaining it than this. Notably
"Magic string auto-increment" isn't. It's
the same as the sample preceeding it. It just
so happens that perl lets you do nice things
like perl -e "print ++($_='a')".
Also, it might have been worthwhile to give
a tip of the hat to ...

When putting a smiley right before a closing parenthesis, do you:

Use two parentheses: (Like this: :) )
Use one parenthesis: (Like this: :)
Reverse direction of the smiley: (Like this: (: )
Use angle/square brackets instead of parentheses
Use C-style commenting to set the smiley off from the closing parenthesis
Make the smiley a dunce: (:>
I disapprove of emoticons
Other