If you can in your case, you could use the non-string form of eval:

sub emphasizePrint
{
  my $k = "!!\n";
  return sub {
    my ($str) = @_;
    eval {
        print "$str$k"
    };
    print STDERR "Error: $@" if ($@);
  }
}
[download]

If that isn't applicable in your case I know no other way around than mentioning the variables in the closure once.

No, the problem is that $k is not available (slightly different than garbage collected). It is included in the closure, as this demonstrates:

use strict;
use warnings;

$::clos = $::clos = "global";

sub foo {
   my $clos = shift;
   my $sub = shift;
   &$sub() if $sub;
   return sub {
      eval 'print "$clos\n"'
   }
}

foo("baz", foo("bar"));
[download]

The first (inside) call to foo returns a closure on foo's $clos. The second call to foo calls the closure, which does get the closed-over $clos. But there is a problem: entering foo the second time reuses the same lexical $clos, since perl isn't aware that the first call will be referring to it, so as an optimization doesn't bother allocating a new lexical.

Note that in 5.10.0, the OP's problem code gives a warning:

Variable "$k" is not available at (eval 1) line 1.
[download]

--
Online Fortune Cookie Search

moritz has pretty much answered the technical aspect of your question, but now I am curious about your design choice. What are you trying to accomplish with this closure you are creating? There is a good chance that there is a different way of doing what you are looking for that is less complicated

My instinct is that you are trying to perform some sort of wrapping functionality with out increasing the stack frame you are working with. In otherwords, do something, then call your function, but keep @_ exactly as was originally called. Below is an example.

use strict; 
 
sub trace_wrapper_no_frame { 
    my $f=shift; 
    return sub { 
        print "Trace, no frame\n"; 
        goto $f; 
    }; 
} 
 
sub trace_wrapper_frame { 
    my $f=shift; 
    return sub { 
        print "Trace, with frame\n"; 
        $f->(@_); # <----- LINE 15 
    }; 
 
} 
 
sub who_says_hello {  
    print(join(" ",caller), "\n"); 
    print "Hello, $_[0]\n"; 
} 
 
 
who_says_hello("World"); # <------ LINE 26 
 
print '-' x 20, "\n"; 
 
my $frame_wrapped_hello = trace_wrapper_frame(\&who_says_hello); 
$frame_wrapped_hello->("dolly"); 
 
print '-' x 20, "\n"; 
 
my $no_frame_wrapped_hello = trace_wrapper_no_frame(\&who_says_hello);
+ 
$no_frame_wrapped_hello->("Fifty"); #<----- LINE 36
[download]

The output looks like the following

From line # 26
Hello, World
--------------------
Trace, with frame
From line # 15
Hello, dolly
--------------------
Trace, no frame
From line # 36
Hello, Fifty
[download]

But don't do that if you don't have to. Hook::LexWrap is a great module that does it all for you, but with more features allowing you to specify pre and post call wrappers, and allows you to lexically scope said wrapping if you so desire.

.... Then again, this might have nothing to do with what you want...

my $print = emphasizePrint();
$print->("Hello World"); ## Prints "Hello World!!"

sub emphasizePrint
{
  my $k = "!!\n";
  return sub {
    my ($str) = @_;
    eval (qq{print "$str$k"});
    print STDERR "Error: $@" if ($@);
  }
}
[download]

That's really a bad idea in the general case, because it won't work if $k has a string terminator in it:

sub emphasizePrint
{
  my $k = qq{"!!\n};
  return sub {
    my ($str) = @_;
    eval (qq{print "$str$k"});
    print STDERR "Error: $@" if ($@);
  }
}
__END__
Error: Can't find string terminator '"' anywhere before EOF at (eval 1
+) line 2.
[download]

In the general case this opens lots of holes, which can be a security risk.

I think that citromatik deliberately interpolated the variables at eval time, not prior to evaling the string.