If the opening curly brace is followed by a string and a comma (, or =>), perl guesses it's an anonymous hash. Anything else, and perl guesses it's a block. This heuristic works most of the time, but in some cases perl guesses wrong:

# a block returning a list of two elements,
# but perl thinks it's an anonymous hash
%hash = map { "$_", 2 } @l;

# an anonymous hash, but perl thinks it's a block
@hash_refs = map { $_, 2 }, @l;
[download]

# force parsing as a block
%hash = map { +"$_", 2 } @l;
%hash = map { ; "$_", 2 } @l;
%hash = map { ( "$_", 2) } @l;

# force parsing as an anonymous hash
@hash_refs = map +{ $_, 2 }, @l;
[download]

Can I ask a silly question? What does the + mean to Perl in these examples. I don't ever recall seeing it ever used in such a way.

-Lee

"To be civilized is to deny one's nature."

It's like making explicit the implicit '+' that precedes any non-negative number (think scalar ::= number or string).

Do you remember, when learning how to format numbers for output (using '%f', '%g', etc.) with printf in C, you had to account for the sign position? It would display as either a hyphen or blank. A blank, however, was analagous to a plus-sign.

Likewise, on input, non-negative numbers could optionally be expressed with a leading plus-sign. Since scalars (or scalar expressions) may be either numbers or a strings in perl, perl allows this with arbitrary scalar expressions.

dmm

You can give a man a fish and feed him for a day ...
Or, you can teach him to fish and feed him for a lifetime

Unary minus negates its operand, either adding a minus sign, or switching a minus sign to a plus sign or vice versa. Unary plus, on the other hand, returns its operand completely unchanged. Why is this useful? It can come in handy when dealing with ambiguous syntax.

More examples of unary plus:

print (3-1)*2;      # oops!  print (...) interpreted as function ...
print +(3-1)*2;

sub foo { $foo }
$h{foo};            # equivalent to $h{'foo'}
$h{+foo};           # but maybe you meant $h{foo()}
[download]

See perlop for more on this curious operator.

It would appear that, because of what you have put inside the {...}, Perl is taking that to be an expression and thus needing a comma after it.

use strict;
my @l = 1..10;
map { 1, 2 }, @l;
map { "$_", 2 }, @l;
[download]

print map { 1, 2 }, @l;
print map { "$_", 2 }, @l;
[download]

------------------------------------------------------------
"Perl is a mess and that's good because the
problem space is also a mess." - Larry Wall

I was thinking along the same lines, but the fact that the following does work seems to contradict this argument, or at least imply that it's not the whole story:

map { $_, 2 } @l;
[download]

Though, now that I think about it, all this probably reflects a perl heuristic/optimization in the parser which says something along the lines of "if, within the bracketed expression, I see a constant and then a comma, I'm going to assume the expression is a hash, and not a block, no matter what comes afterwards...."

   MeowChow                                   
               s aamecha.s a..a\u$&owag.print

map {($_, 2)} @l;
[download]

update: Howdy folks, I'm a slowhand luke

 
___crazyinsomniac_______________________________________
Disclaimer: Don't blame. It came from inside the void
perl -e "$q=$_;map({chr unpack qq;H*;,$_}split(q;;,q*H*));print;$q/$q;"