my %hash = map {$_ => sub {return "<H1>$_</H1>"} } (1..5); 
$_ = 'foo';
print &{$hash{2}};
[download]

my %hash = map {$_ => "<H1>$_</H1>" } (1..5);
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

no that wouldn't work.

I wouldn't be using sub's unless I needed to use subs.

I thought it was kind of ghetto to have to resort to eval to get $_ to be have properly (yeah I knew it was global, but it should've been local to block, and once the sub's were compiled, IMHO, it shouldn't need to stay shared).

Thanks anyway

Eval is probably not as bad as you think. If the little extra compilation overhead is a significant portion of your program's run time, you probably shouldn't be building this coderef laden hash anyway.

Local creates a temporary copy of the variable, but it stays global, so there's no reference count increased when you use it in the anonymous sub. When the scope ends, the temporary copy is simply discarded.

my creates a new lexical, our is a lexically scoped "use vars", local creates a temporary copy of the global that will be used while the lexical scope lasts.
Only lexicals can stay shared.
(I have probably made some mistakes or mis-assumptions. If you see any, please do correct me)

Lbh ebgngrq guvf grkg naq abj lbh pna ernq vg. Fb jung? :)   -- Whreq
[download]

map { $_ => eval "sub { '<H1>$_</H1>' }" } 1..5
[download]

Lbh ebgngrq guvf grkg naq abj lbh pna ernq vg. Fb jung? :)   -- Whreq
[download]

Do not declare $a and $b as lexical variables (with my). They are package globals (though they're exempt from the usual restrictions on globals when you're using use strict).

As it turns out, it doesn't cause a problem in this isolated snippet of code, but I recommend you use the solution offered by jeffa.

--Jim

The usage of $a and $b in this context wouldn't hurt him, since there isn't a sort being evaluated. However, it's just as easy to use less-confusing names, or use one of the other methods offered.

--rjray

#!/usr/bin/perl

my @answers = map { return_tag ($_,'H1') } 1..5;

foreach my $answer (@answers){
    print $answer->(),"\n";
}

sub return_tag {
    my ($arg,$tag) = @_; # Will be caught in closure.
    return sub { "<$tag>".$arg."</$tag>" };
}
[download]

i bet $_ gets a special instance when inside a sub{}.

whaddyathink?

how about:

map { $_ => eval qq(sub{"<h1>$_</h1>"}) } 1..6

here the $_ gets evaluated inside map{} before being inside the sub{}

hmm?

$_ is less special than you think. It wouldn't have worked with a global named $foo either. The eval-solution you gave has already been given (by yours truly).



use vars qw($foo);
{
    $foo = 'foo';
    sub xyzzy {
        print "$foo\n";
    }
}
$foo = 'bar';
xyzzy(); # Prints bar now.
[download]


But:


{
    my $foo = 'foo';
    sub xyzzy {
        print "$foo\n";
    }
}
my $foo = 'bar';
xyzzy(); # Prints the 'foo' that stayed shared.
[download]



Update - s/\$f\b/\$foo/, thanks Kanji.

++ vs lbh qrpbqrq guvf hfvat n ge va Crey :)
Nabgure bar vs lbh qvq fb jvgubhg ernqvat n znahny svefg.
-- vs lbh hfrq OFQ pnrfne ;)
    - Whreq