Like this?

sub x {
   my $func = do { no strict 'refs'; *{caller() . '::_x'}{CODE} };
   die() unless defined $func;
   &$func;
   # or &$func(...);
}
[download]

Test code:

sub x {
  my $package = caller;
  return unless UNIVERSAL::can($package, "_x");
  ...
  eval "${package}::_x"; die $@ if $@;
}
[download]

------------
:Wq
Not an editor command: Wq
[download]

That's potentially too smart by half.

sub x
{
    my $package = caller();
    my $sub     = $package->can( '_x' );
    return unless defined $sub;
    $sub->( @_ );
}
[download]

Why not just pass a reference to the callback sub?

package M;
use strict;
require Exporter;
our @ISA = qw[ Exporter ];
our @EXPORT = qw[ x ];

sub x{
    my( $sub ) = @_;
    &$sub;
}
1;
[download]

#! perl -slw
use strict;
use M;

sub _x{ print __PACKAGE__ . "_x() called" }

x( \&_x );

__END__
P:\test>393046
main_x() called
[download]

The problem is that I'm calling x from an external library so I don't have that freedom. You guys got me on the right track though, thanks much!

How about:

use strict;

package M;

sub x {
    my $caller_package = shift;
    print "Caller: $caller_package\n";
    $caller_package->_x();
}

package main;

sub _x {
    my $class = shift;
    print "$class _x\n";
}

main->M::x();
[download]

output:

Caller: main
main _x
[download]

update: added "shift" in _x - thanks ikegami.

Note: The above has the side effect of passing an extra argument to _x. Probably acceptable.

Yep, got this working. Is there a way to call the function in a different context so as not to have to stick a dinky shift; at the start of _x? I'm trying some of the other discussed options, but can't get them working with passing parameters to _x.