localizing __PACKAGE__?

[perl5ever]

When I create a closure, are unqualified function names permanently tied to a particular package, or is it possible to change what package they will be looked up in at the time the closure is executed?

Example:

package other;
sub hello { ... }

package main;

sub foo {
  # some magic here to make hello -> other::hello?
  $_[0]->();
}

foo(sub { hello() });

When this code is executed, the call hello() will try to call main::hello. However, is it possible to put some magic in foo so that the function call hello() will be resolved as a call to other::hello()?

[Corion]

You can do something like the following but it's a horrible thing to do in the long run:

package main;
sub foo {
    local *main::hello = \&other::hello;
    $_[0]->();
};

What problem are you trying to solve that you can't solve by rewriting the calling code?

[JavaFan]

No, doing it in foo is too late, and short of actually overriding main::hello, you cannot do what you want. The code to hello() is resolved inside the anon sub, not inside foo(). Said sub is compiled inside the package main, so a call to an unqualified sub will be resolved in the package.

You may want to do something like:

foo(sub {package other; hello()});  # Always calls other::hello

or

sub foo {package other; $_[0]->()}
foo(sub {no strict 'refs'; &{(caller)[0] . "::hello"}()}); # Always ca
+ll hello in callers namespace.

[TomDLux]

The better solution would be to be clear when you invoke foo() as to which hello(0) you want it to call. If, instead of passing the anonymous sub to foo(), you were to attempt to invoke hello(), it would fail because there is no hello(). What makes you think it should work any better inside foo()?

foo(sub { other::hello() } );