Co dokładnie robi `subbar {+ {$ _ [1] => $ _ [2]}}`?

Question

Nie rozumiem znak + cukru w ​​tym przykładzie podjęte gdzieś podczas goggling:

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

pisałem to i nie widzę żadnych różnic tutaj:

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 zwraca

$VAR1 = 55; 
$VAR2 = undef; 

bar zwraca

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

Answer 1

Pomaga parserowi rozróżniać anonimowy skrót i blok kodu.

Powołując Learning Perl Objects, References & Modules

ponieważ bloki i anonimowych hash konstruktorzy używają nawiasów klamrowych w przybliżeniu tych samych miejscach w drzewie składni, kompilator musi dokonać ustaleń ad hoc, która z tych dwóch masz na myśli. Jeśli kompilator kiedykolwiek podejmie decyzję niepoprawnie, może być konieczne podanie wskazówki, aby uzyskać to, co chcesz. Aby pokazać kompilatorowi, który ma być anonimowym konstruktorem skrótu, umieść znak plus przed otwierającym nawiasem klamrowym: + {...}. Aby uzyskać blok kodu, wystarczy wstawić średnik (oznaczający pustą instrukcję) na początku bloku: {; ...}.

Albo z dokumentacją dotyczącą map funkcję:

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