Conclusion: dynamic languages are fun.

I need to solved this problem when I was implementing Markapl:

How do I eval this code:

eval 'my @attr = ($x, $y)';

With $x and $y coming from my caller scope ?

sub x_add_one {
    caller_eval '$x + 1';
}

sub ans {
    my $x = 41;
    x_add_one;
}

print ans; #42

It was more generic for Markapl, but the caller_eval can solve the problem in Markapl. Today, I re-factor that piece of work into a standalone moulde, Binding.pm

You can see the solution to this problem in other dynamic languages. The uplevel function in Tcl language and Binding.of_caller method in Ruby (extension.)

I give it the same name as in Ruby. Binding. Here’s a brief synopsis of how to use it:

my $binding = Binding->of_caller;
$binding->eval('$x + 1');

The code examples given in here are all special instances, since the evaled code actually specified the variable $x to use by its name. In the implementation of Markapl, the names of variables is also stored in a variable, so I needed a generic solution. (ps. That part was lately re-implemented and does not require this eval now.)

The implementation is to use peek_my function from PadWalker with pp from Data::Dump to clone caller’s lexical variables. It’s not a perfect way but it’s a beginning.

These are not implemented, but some good targets to try:

• Binding->of_package
• Binding->of_sub
• Binding->local

It can be easily seen that these are quite challenging and probably impractical. More like an experimental and research-kind of work.

BTW, then I can just use this in my Rubyish.pm too.

This piece of work is already uploaded to CPAN: http://search.cpan.org/dist/Binding/, while its source code repository is hosted on Github: http://github.com/gugod/binding/tree/master. Please take a look and give me some feedback.