my $code_ref = $self->can('myFunction');
unshift @_, $self; # Assuming you don't already have an invocant in @_
goto &$code_ref;
[download]

use strict;
use warnings;
use 5.010;

package Foo;

sub x {say "Hello"}

package main;

foo();

sub foo {
    my $obj = bless [], 'Foo';
    my $sub = $obj->can('x');
    goto &$sub
}
__END__
Hello
[download]

You'll probably want to unshift @_, $obj before goto &$sub to get the invocant into the argument list.

It has been said that Perl is a loaded gun pointed right at your foot. If that is true, then Perlmonks is the shooting range. Ask ... and ye SHALL receive.

Now, while the good monks have already shown you how to do what you want, someone else really needs to come along and say -- why do need to do that? Don't do that. Wouldn't this work just as well?

my $result = $self->myFunction();
[download]

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Why are you using a goto on a ref to a method when you already have a ref to it

I'm not the OP, so I can only speculate on what the intention might have been...  but maybe the idea was to not mess up the call stack? Compare:

#!/usr/bin/perl

package Foo;

use Carp "cluck";

sub new {
    my $class = shift;
    return bless { @_ }, $class;
}

sub myFunction {
    my $self = shift;
    cluck $self->{msg};
}

sub foo1 {
    my $self = $_[0];
    my $func = $self->can('myFunction');
    goto &$func;
}

sub foo2 {
    my $self = shift;
    my $func = sub { $self->myFunction };
    goto &$func;
}

sub foo3 {
    my $self = shift;
    $self->myFunction();
}


package main;

my $obj = Foo->new( msg => "foo" );
$obj->myFunction();    # direct call
$obj->foo1();          # indirect, using goto (transparent)
$obj->foo2();          # indirect, using goto via closure
$obj->foo3();          # indirect, using regular call via $self
[download]

Output:

foo at ./722627.pl line 16
        Foo::myFunction('Foo=HASH(0x63c430)') called at ./722627.pl li
+ne 40
foo at ./722627.pl line 16
        Foo::myFunction('Foo=HASH(0x63c430)') called at ./722627.pl li
+ne 41
foo at ./722627.pl line 16
        Foo::myFunction('Foo=HASH(0x63c430)') called at ./722627.pl li
+ne 27
        Foo::__ANON__() called at ./722627.pl line 42
foo at ./722627.pl line 16
        Foo::myFunction('Foo=HASH(0x63c430)') called at ./722627.pl li
+ne 33
        Foo::foo3('Foo=HASH(0x63c430)') called at ./722627.pl line 43
[download]

Only the goto variant of foo1() is leaving behind a call stack comparable to the direct call.

    return $self->myFunction;
[download]

# Pick a method, wrap it up an a coderef and return it
sub method_chooser {
  my $self = shift;
  return (rand % 2) : ? sub { $self->runAlice; } : sub { $self->runCha
+rlie };
}

sub do_stuff {
  my $self = shift;
  # Dunno what the chooser will choose
  my $code_ref = $self->method_chooser();
  # But run it all the same
  $code_ref->();
}
[download]

You can't goto a reference.   Have you tried goto &{$self->myFunction}?

I think perhaps this is what you are a looking for:

my $meth = 'myFunction';
$obj->$meth(@args);
[download]

my $meth = $obj->can('myFunction');
$obj->$meth(@args);
[download]

If you actually want a code reference to the method so that you can call it later on and have everything Just Work, then you want to use a closure like this:

my $meth = sub { $obj->myFunction(@_) };
[download]

$meth->(@args);
[download]