You can pass a reference to a sub, and let other code call that whenever you like...

use strict;
use warnings;
{
  my $subref = sub { print "Hey, Hey!\n"; };
  Foo($subref);
}
exit 0;

sub Foo
{
    my $callback = shift;
    print "Foo started\n";
    $callback->();
    print "Foo is done\n";
}
[download]

Should call "foo" after compilation (not during BEGIN). Could the module somehow define an INIT block that calls the sub?

The problem with that is that modules INIT and runtime are still compile time from the perspective of the calling script.

You could run it in an END block, which is also after compilation, but I could imagine that that's too late for your purpose. So I don't know any solution, except via source filters (or maybe evil hijacking of DESTROY subs, depending on when exactly the routine should run).

Speaking of which, what is your purpose? Maybe there's a better solution to it if we know the bigger picture.

I just wanted to facilitate the use of a Module and avoid exorting into the caller's namespace. In particular, the Module does not just call the method but does some processing to pass it the right parameters. The same could be done with an export:

use My::Module qw(call);

call(\&foo);

sub foo { ... };
[download]

I am not that familiar with the processing phases BEGIN,INIT,END, that's why I asked. Is there a way to call the method at the END of execution of the caller?:

use My::Module call => 'foo';

sub foo { ... };

# foo is called at the end
[download]

I am not that familiar with the processing phases BEGIN,INIT,END, that's why I asked. Is there a way to call the method at the END of execution of the caller?

END time is the same for all, so yes, that works:

# file CallMe.pm
package CallMe;
use 5.010;
use strict;
use warnings;

my @to_call;

sub import {
    my ($self, @routines) = @_;
    my $call_package = (caller(1))[0];
    push @to_call, $call_package. "::$_" for @routines;
}

END {
    no strict 'refs';
    $_->() for @to_call;
}

1;
[download]

And then in your script:

use 5.010;
use lib '.';
use CallMe 'foo';

sub foo { say 42 }
say 'in mainline';
[download]

prints

in mainline
42
[download]

Perl 6 - the future is here, just unevenly distributed

The same mechanisms pragmas use to clean themselves up can be used here. Here's an example:

call_when_scope_is_compiled.pm:

package call_when_scope_is_compiled;

use Sub::ScopeFinalizer qw( scope_finalizer );

sub import {
   my ($class, $sub) = @_;
   $^H{__PACKAGE__ . '::'} =
      scope_finalizer { $sub->() };
}

1;
[download]

$ perl -E'
   say "post";
   use call_when_scope_is_compiled \&foo;
   sub foo { say "foo!" }
   BEGIN { say "pre"; }
'
pre
foo!
post
[download]

It also works for narrower scopes.

$ perl -E'
   {
      use call_when_scope_is_compiled \&foo;
      sub foo { say "foo!" }
      BEGIN { say "pre"; }
   }
   BEGIN { say "post"; }
'
pre
foo!
post
[download]

B::Hooks::EndOfScope or perhaps Hook::AfterRuntime (or even a combination of the two) ought to do the trick.

This is an excellent application for what is known in computer-science circles as a closure.   Which Perl supports very well.

You can, within a subroutine, define a variable to be a “code reference,” that is to say, to a particular sub that you define on-the-spot and which can refer to local variables or anything else that is “visible” at the particular place where you define that sub.  

Your caller should simply define one of those closures, and pass it in as a parameter to the routine, who simply calls it.   The closure will execute in the context of the code that created it ... that is to say, “your caller.”

“It’s slick to the point of being positively elegant,” and it works.   (May I kindly refer you to a plethora of existing docs here and elsewhere on the Internet for the gory procedural details.)

use My::Module call => sub {
  ...
};
[download]

The catch is that if the anonymous subroutine you pass to the module gets called directly from within the import() subroutine, you may not call subroutines defined under the use statement. So you may have to move the use statement a little lower in the code. It doesn't have to be right on top!

Does this do what you want?

#!/usr/bin/perl

use strict;
use warnings;
use v5.10;
sub YadaYada {
    say "YadaYada";
     };
use Xyzzy (\&YadaYada);

say "Executing ".__PACKAGE__;
INIT { say __PACKAGE__."::INIT"; };
END { say __PACKAGE__."::END"; };
[download]

package Xyzzy;

use Data::Dumper;
use strict;
use warnings;
use v5.10;

my $external;
sub import {
    shift;
    $external=$_[0];
     };
say "Executing ".__PACKAGE__;
INIT { say __PACKAGE__."::INIT"; $external->(); };
END { say __PACKAGE__."::END"; };
     1;
[download]

yields

Executing Xyzzy
Xyzzy::INIT
YadaYada
main::INIT
Executing main
main::END
Xyzzy::END
[download]