eval('&' . $action . '()');
if( $@ ) {
    die "Usage\n";
}
[download]

my $subref = \&{$action};
die "Usage" unless defined &$subref();
[download]

There's just no good reason to use OO here, and it makes the code more confusing and JAPH-ish. Maybe there's something else in your program that justifies OO, but this problem doesn't.

Incidentally, a nicer way to write that dispatch table from your above comment would be something like this (untested):

my %dispatch = (
                'this' => \&do_this,
                'that' => \&do_that,
               );

if (defined $dispatch{$action}) {
    &$dispatch{$action};
} else { die "Usage\n"; }
[download]

I actually agree it is sort of JAPHish - that's why I posted it as a question here. I went through thinking about a dispatch table exactly the way you proposed, as I already explained in my reply to chromatic, but it has the same problem as the switch-construct: adding an "action handler" requires maintaining the dispatch table. I could have put the handlers as anonymous subs right into the dispatch table, but then I have to define them before the body of the main program and they're very long. (The biggest one is 2.5 pages of straight-through code without any loops.)

I sort of like your eval proposition, though the idea of circumventing strict in whichever fashion irks me. :-)

Thinking about it some more I think the sole reason it turns JAPHish is the role I have given to new() - that's the single thing I would point out as contrived in retrospect. I wonder if it's possible (and what you'd think) of doing something along the following lines:

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

print "\nfoo script\n\n";

my $action = shift(@ARGV);

die "Usage here\n" unless $action;

my $handler = can main "_$action";

die "Unknown action '$action'\n\nUsage here\n" unless ref $handler;

my %params;
GetOptions(\%params, qw(various options here));
# do more stuff with %params here

$handler->(\%params);

exit;

######################################################################
+##
######################################################################
+##
use Getopt::Long;
# use Other::Modules::Here;

# .. etc ..
[download]

I'd suggest moving the "use Getopt::Long" to the top part, since that's where you actually use the module, and giving the lower section a real package name ("package MyTool" or something). Then instead of this:

my $handler = can main "_$action";
[download]

you can have this: this:

my $handler = MyTool->can("_$action");
[download]

Easier to follow, in my opinion.

Incidentally, a nice way to code tools like this is to make a separate module that implements all of the real logic, and then a CLI wrapper that just calls that module's methods. Then you can easilly add a GUI, call it from CGI, etc.