CODEWITHSUNDEEP
perl
Miller
Miller

Reputation: 35208

map failing to parse with 2 element unparenthesis list in a block

The following Perl script will fail to compile: 

#!/usr/bin/env perl

use warnings;
use strict;

my $vex = [ { _dirty => "muddy waters" } ];

print map { "$_", $vex->[$_]{_dirty} } ( 0 .. $#$vex );

Outputs:

syntax error at map.pl line 8, near "} ( "
Execution of map.pl aborted due to compilation errors.

I can fix this by putting the 2 element list within parenthesis

print map { ( "$_", $vex->[$_]{_dirty} ) } ( 0 .. $#$vex );

Alternatively, removing the quotes around the any variable removes the parsing issue, but those were needed in the original, more complicated usage.

Bug in Perl? I've gone ahead and reported it.

Upvotes: 2

Views: 42

Answers (1)

ysth
ysth

Reputation: 98423

perldoc -f map:

{ starts both hash references and blocks, so map { ... could be either the start of map BLOCK LIST or map EXPR, LIST. Because Perl doesn't look ahead for the closing } it has to take a guess at which it's dealing with based on what it finds just after the {. Usually it gets it right, but if it doesn't it won't realize something is wrong until it gets to the } and encounters the missing (or unexpected) comma. The syntax error will be reported close to the }, but you'll need to change something near the { such as using a unary + or semicolon to give Perl some help:

%hash = map {  "\L$_" => 1  } @array # perl guesses EXPR. wrong
%hash = map { +"\L$_" => 1  } @array # perl guesses BLOCK. right
%hash = map {; "\L$_" => 1  } @array # this also works
%hash = map { ("\L$_" => 1) } @array # as does this
%hash = map {  lc($_) => 1  } @array # and this.
%hash = map +( lc($_) => 1 ), @array # this is EXPR and works!
%hash = map  ( lc($_), 1 ),   @array # evaluates to (1, @array)

or to force an anon hash constructor use +{:

@hashes = map +{ lc($_) => 1 }, @array # EXPR, so needs
                                       # comma at end

to get a list of anonymous hashes each with only one entry apiece.

Personally, I prefer map {; ... to force it to interpret { as the start of a BLOCK.

Upvotes: 6

Related Questions