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

{   package My;
    sub new { bless {}, shift }
    sub show { my ($self, $name) = @_; print "Hello $name!\n" }
}

my $A = 'My'->new;

my $method = shift;
$A->$method(@ARGV);
[download]

Using it:

$ 1.pl show World
Hello World!
[download]

Otherwise, you need to do a reference/dereference trick:

$A->${\ $ARGV[0] }(@ARGV[1 .. $#ARGV]);
[download]

Update: Fixed arguments for the second example. Thaks etj.

To be exactly equivalent, that last one would need to be: $A->${\ $ARGV[0] }(@ARGV[1..$#ARGV]);

Choroba showed you how to do it, however allowing calls to arbitrary functions can be a bit of a security hole. To get around that I usually decorate the sub name after the user has provided it:

use strict;
use warnings;

package My;

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

sub ext_show {
    my ($self, $name) = @_;
    print "Hello $name!\n";
    return 1;
    }

package main;

my $A = 'My'->new();
my $method = 'ext_' . shift;

$A->$method(@ARGV);
[download]

Prints:

Hello Bob!
[download]

when given the command line parameters show Bob. Because 'ext_' is added a prefix to the actual name it's not possible for the user to call an unintended sub.

Or use a whitelist:

my $A = My::->new();
my $method = $method_list{$ARGV[0]}
    or die "Invalid method $ARGV[0].";
$A->$method(@ARGV[1..$#ARGV]);
[download]

--
A math joke: r = | |csc(θ)|+|sec(θ)| |-| |csc(θ)|-|sec(θ)| |

I have done that in the past, but the list, the implementation and the documentation all have to be updated. Using the prefix trick avoids the need to update the list. I admit, a fairly minor point, but it does reduce scope for error.

Optimising for fewest key strokes only makes sense transmitting to Pluto or beyond

Calling a sub:

my $sub = \&$name;
$sub->( @args )
[download]

Optionally, you can add the following:

die "No sub named `$name`" if !defined( &$sub );
[download]

Note that \&$name will create an undefined sub if it doesn't already exists.

Calling a method:

$invocant->$name( @args )
[download]

Calling a method (alternative):

my $method = $invocant->can( $name );
$invocant->$method( @args )
[download]

Optionally, you can add the following to the alternative approach:

die "No method named `$name`" if !$method;
[download]

Strict refs prevents none of these.

use strict;
use warnings;

package Acme::Bad::Idea {
    sub new { bless {}, shift }

    sub do_not_do_this {
        warn shift;
        ...;
    }
};
my $bad_idea = Acme::Bad::Idea->new();
# @ARGV = qw[do_not_do_this seriously];
$bad_idea->can( $ARGV[0] )->( $ARGV[1] );
[download]