A dispatch table of the funcs:

#! perl -slw
use strict;

my %dispatch = (
    A => sub{ map{ $_ +1 } @_ },
    B => sub{ map{ $_ *2 } @_ },
    C => sub{ map{ $_**2 } @_ },
    D => sub{ map{ $_ +3 } @_ },
    E => sub{ map{ $_ *5 } @_ },
);

my $func_com = $ARGV[ 0 ] || 'ABC';
my @some_val = 1 .. 10;

@some_val = ( 
    $dispatch{ $_ } || sub{ @_ } 
)->( @some_val ) for split '', $func_com;

print "$func_com: [ @some_val ]";

__END__
c:\test>junk6
ABC: [ 16 36 64 100 144 196 256 324 400 484 ]

c:\test>junk6 A
A: [ 2 3 4 5 6 7 8 9 10 11 ]

c:\test>junk6 B
B: [ 2 4 6 8 10 12 14 16 18 20 ]

c:\test>junk6 AB
AB: [ 4 6 8 10 12 14 16 18 20 22 ]

c:\test>junk6 C
C: [ 1 4 9 16 25 36 49 64 81 100 ]

c:\test>junk6 AC
AC: [ 4 9 16 25 36 49 64 81 100 121 ]

c:\test>junk6 ABCDE
ABCDE: [ 95 195 335 515 735 995 1295 1635 2015 2435 ]

c:\test>junk6 F
F: [ 1 2 3 4 5 6 7 8 9 10 ]

c:\test>junk6 FA
FA: [ 2 3 4 5 6 7 8 9 10 11 ]
[download]

Something like...

my %dispatcher =
(
 A => \&func_A,
 B => \&func_B,
 C => \&func_C,
 #etc
);

my @temp_results;
for my $cat ( 'A' .. 'E' )
{
    push @temp_results, [ $dispatcher{$cat}->( @some_val ) ]
        if $func_com =~ m/$cat/; # index is better
}
push @all_res, \@temp_results;

# Do something with @all_res
[download]

my %funcs = ('A'=>\&func_a, 'ABC'=>\&func_c); #etc
#...
#and then call it as
push @res, $funcs{$func_com}->(@someval);
[download]

update checking for existance of function in the hash was left as an excercise for a reader
:)

I think a dispatch table will rapidly become unwieldy if you need to consider all possible function call combinations of A, B, C, D and E. Assuming A must always be called first, and C must be called between B and D (if present), and so on, you are looking at the power set of A .. E. And the size of the power set of a set increases exponentially.

Here's all the different ways you can call functions A to E:

perl -MData::PowerSet -le 'my $p = Data::PowerSet->new(qw(A B C D E));
+ print "@$_" while $_= $p->next'
# produces :
A B C D E
B C D E
A C D E
C D E
A B D E
B D E
A D E
D E
A B C E
B C E
A C E
C E
A B E
B E
A E
E
A B C D
B C D
A C D
C D
A B D
B D
A D
D
A B C
B C
A C
C
A B
B
A
[download]

Add three more function and the size of your dispatch table grows to 256 entries... and it gets much worse if you can call any of A to E in any order.

I think it would be much better to just split your 'ABC' input into separate characters, and use a simple dispatch to deal with the five (or more) elementary cases:

my %dispatch = (
    A => \&func_a,
    B => \&func_b,
    C => \&func_c,
    D => \&func_d,
    E => \&func_e,
);
for my $token (split //, $func_com) {
    push @all_res, [$dispatch{$token}->(@some_val)];
}
[download]

This way it is as trivial to deal with 'ABC', 'AD', 'BCE' as it is to deal with 'AABD' or 'BEAD'.

my %table = map { $_ => \&{'func_'.$_} } 'A'..'E';
for (split //, $func_com) {
    push @all_res, [ $table{$_}->(@some_val) ];
}
[download]

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Here's another way. Its suitability is something you'd have to decide...

$func_com =~ y/ABCDE//cd;

$func_com =~ s/(.)/func_$1();/g;

eval $func_com;
[download]

Here's another technique which is kind of like a combination of both the dispatch table, as presented elsewhere in this thread, and interpreting the 'ABC' string directly as code. I think it's generally better, especially in an application architecture which is already object oriented.

{
    package Funcs;
    use Carp;

    sub A { print "A!\n" }
    sub B { print "B!\n" }
    sub C { print "C!\n" }
    sub D { print "D!\n" }
    sub E { print "E!\n" }

    sub AUTOLOAD
    {
        our $AUTOLOAD;
        carp "no $AUTOLOAD";
    }
}

# now, wherever $func_com comes from...

Funcs->$_() for split //, $func_com;
[download]

Of course, you may have other ways of parsing $func_com, rather than just by single characters; and other ways of validating it in addition to making the calls and barfing on non-existent methods.

A word spoken in Mind will reach its own level, in the objective world, by its own weight

With the same caveat of Caution!, that could be reduced to:

$_ = 'ABCDEDBCA ABCDEFGFEDCBA'; 
s[([A-E])][ "func_$1" ]gee;;
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."