Yes, using the reference/dereference trick:

$object->${\method()}(@args);
[download]

Here, method() is called, a reference to the result is taken through the backslash, and that reference is de-referenced via ${ }. The resulting method is called on behalf of $object, passing along @args.

Thank you! This works!
-- 
Ronald Fischer <ynnor@mm.st>

use strict;
use warnings;
use 5.010;

sub f { 'g' }
sub g { say 'in g()' };

(bless {})->can(f())->();
[download]

Looks great, but this doesn't work if the method expects parameters. For instance:

package Obj;

sub new {
  my $class=shift;
  my $self={ x => 'uh' };
  bless $self, $class;
}

sub howl {
  my ($self,$arg)=@_;
  print($self->{x}," $arg\n");
}

package main;

sub mname { 'howl' }

my $x=Obj->new();
$x->howl('oh');
$x->can(mname)->('ah');
[download]

The reason is that can() returns only a reference to the method, but the object ($x) is lost on the way. A workaround would be

$x->can(mname)->($x,'ah');
[download]

but this is ugly, since it requires us to mention the object twice.
-- 
Ronald Fischer <ynnor@mm.st>

Is there a reason why you don't add the dispatcher as an extra method to the class MyObj?

$obj->dispatcher(@arguments)
[download]

And even if you need this flexibility and don't care about encapsulation and DRY, you can still define a method call():

$obj->call(dispatcher(), @arguments)
[download]

giving you more and deeper possibilities to catch possible errors.

(Sorry for the late response. I had an accident and was "away from Perl" for nearly 7 weeks)

Sorry, this design looks strange, IMHO it breaks OOP paradigms.

It does so on purpose. The code in question has to do with introspection, i.e. method name and arguments come from the outside. See it as kind of a debugging aid.

Aside from this, I found the question by itself interesting too ;-)
-- 
Ronald Fischer <ynnor@mm.st>