$pack->can("${method}2")->()
[download]

 $pack->"${method}2"(); # <-- doesnt compile

Even Perl's syntax has its limits...  :)

But you could do (if you really can't resist):

$pack->${\($method."2")};
[download]

Ahh of course. How perfectly arcane.

>perl -wMstrict -le
"package base;
   sub func {
     print q{in }, __PACKAGE__, qq{ via $_[0] got $_[1]};
     }
 package derived;
   our @ISA = qw(base);
 package main;
   my $pack = 'derived';
   $pack    ->func(42);
   'derived'->func(42);
   my $foo = 'fu';
   $pack->can(qq{${foo}nc})->(42);
   no strict 'refs';
   &{ $pack->${\qq{${foo}nc}} }(42);
   $pack->${\qq{${foo}nc}}->(42);
"
in base via derived got 42
in base via derived got 42
Use of uninitialized value in concatenation (.) or string at ...
in base via 42 got
Use of uninitialized value in concatenation (.) or string at ...
in base via derived got
Undefined subroutine &main::1 called at -e line 1.
[download]

Sure. You can do either of:

my $meth = $pack->can("${method}2");
$pack->$meth(@args);
[download]

or more simply, if you can give the object twice:

$pack->can("${method}2")->($pack, @args);
[download]

-- Randal L. Schwartz, Perl hacker

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.

...can be tortured into passing both the invoking class and method arguments

No torturing required... just omit the arrow :)

#!/usr/bin/perl -wl
use strict;

package base;
  sub func {
    print q{in }, __PACKAGE__, qq{ via $_[0] got $_[1]};
    }

package derived;
  our @ISA = qw(base);

package main;
  my $pack = 'derived';
  my $foo = 'fu';
  $pack->${\qq{${foo}nc}}(42);

__END__
in base via derived got 42
[download]


Update: When you write

  $pack->${\qq{${foo}nc}}->(42);
[download]

you're trying to call a subroutine named like what's returned by func() (here 1, the return value of the print) ...

Anyhow, some related food for thought:

#!/usr/bin/perl
use strict;
use warnings;

*{main::1} = sub { print "1() called with args: @_\n" };

main::1(42);          # 1() called with args: 42
main::1->(42);        # 1() called with args: 42
1->(42);              # 1() called with args: 42

main->${\1}(42);      # 1() called with args: main 42

no strict 'refs';
main->${\1}->(42);    # 1() called with args: main
                      # 1() called with args: 42
[download]

(I particularly like the 1->(42) :)

(I particularly like the  1->(42) :)

This seems a bit like the code one comes up with at about 1:42 AM!

Anyway, I'll have to do some reading to convince myself this is all perfectly kosher.