use strict;
my %config_A = (A=>'a');
my %config_B = (B=>'b');
my $calls = {
    A => \&print_A(\%config_A),
    B => \&print_B(\%config_B),
};

my $test = 'A';
$calls->{$test};

sub print_A {
        my $config = shift();
        print $config->{A},"\n";
}
sub print_B {
        my $config = shift();
        print $config->{B},"\n";
}
[download]

Then you'll need to wrap the calls in anonymous subs:

my $calls = {
    A => sub{ print_A( \%config_A ); },
    B => sub{ print_B( \%config_B ); },
};

my $test = 'A';
$calls->{$test}();
[download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

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.

Not sure i like the lock-in you get with the anon sub approach. I would make the config hash have both the sub references and the options references -- that way if you ever needed to override the options, it's a bit cleaner

   ....
  my $calls => {
     A => { sub_ref => \&print_A, config_ref => { ... } },
     B => { sub_ref => \&print_B, config_ref => { ... } }
  };

  my $test = 'A';
  my $sub  = $calls->{$test}{sub_ref};
  my $config = $calls->{$test}{config_ref};

  $sub->( $config );
[download]

-derby

Thanks a lot!

You need to pass the parameters when you call the function, not when you store the reference.

See tye's References Quick Reference.

# Here you take the reference to the subroutine
my $calls = {
    A => \&print_A,
    B => \&print_B,
};


# Here you call the subroutine
$calls->{ $test }->(\%config_A);
[download]

When taking the reference, you should never use parentheses.

Using Data::Dumper on %calls would show you what Perl stored in %calls.

Thanks but I need to pass %config_A when $test is A, and %config_B when $test is B.