What does `sub bar { +{$_[1] => $_[2]} }` exactly do?

Question

I don't understand the + sugar sign in this example taken somewhere while goggling:

sub bar { +{$_[1] => $_[2]} }

I wrote this and I don't see any differences here:

use Data::Dumper;

# Not any differences here
my $foo =  {value => 55};
my $bar = +{value => 55};

print Dumper $foo;
print Dumper $bar;

# Oh ! Here there is something...
sub foo {  {$_[1] => $_[2]} };
sub bar { +{$_[1] => $_[2]} };

print Dumper foo('value', 55);    
print Dumper bar('value', 55);

foo returns

$VAR1 = 55;
$VAR2 = undef;

bar returns

$VAR1 = {
          '55' => undef
        };

You are already using Data::Dumper, so I simplified and made it runnable by more people — ikegami, Jul 03 '15 at 16:07

score 16 · Accepted Answer · edited Jul 03 '15 at 12:57

It helps the parser to distinguish between an anonymous hash and a code block.

Citing Learning Perl Objects, References & Modules

because blocks and anonymous hash constructors both use curly braces in roughly the same places in the syntax tree, the compiler has to make ad hoc determinations about which of the two you mean. If the compiler ever decides incorrectly, you might need to provide a hint to get what you want. To show the compiler that you want an anonymous hash constructor, put a plus sign before the opening curly brace: +{ ... }. To be sure to get a block of code, just put a semicolon (representing an empty statement) at the beginning of the block: {; ... }.

Or from the documentation on the map function:

"{" 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.

What is the method to use to find this documentation? I tried goggling `perl "+{}" and `perl "+{ ... }"` or even `perl plus sign hash`. I did not find anything relevant. What's your magic trick? — nowox, Jul 03 '15 at 08:21
I 'know' it from reading the documentation on `map` http://perldoc.perl.org/functions/map.html — Sobrique, Jul 03 '15 at 08:28
I googled "perl hash plus sign" and got the link as the first hit. — Matteo, Jul 03 '15 at 08:39
@Sobrique Thanks for the reference: I added it to the answer — Matteo, Jul 03 '15 at 09:05
@nowox you can also try using http://symbolhound.com/ which is good for searching stuff which google strips out — simbabque, Jul 03 '15 at 09:53

What does `sub bar { +{$_[1] => $_[2]} }` exactly do?

1 Answers1