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]

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

Not sure i like the lock-in you get with the anon sub approach.

Personally, I see your method causing more lock-in than mine. You're committing them to a single parameter.

Of course, you can then make it an anonymous array, and pass that.

But now you are creating yet another level of indirection and nesting, and parallel data structures, all of which then needs to be mentally unwound to work out what gets passed to what.

The delegate -- anonymous sub that encapsulates code references along with their arguments (by closure) -- is a very well tried and tested mechanism used by FP languages almost exclusively. It's clear, concise and can usually be in-lined.

---

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.

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.

Then consider passing the appropriate parameter, depending on $test?

my $config= 'A' eq $test
            ? \%config_A
            : \%config_B;
[download]

Or even better, do the same for your data as you already did for your code:

my %config= (
    A => \%config_A,
    B => \%config_B,
);

my $config= $config{ $test }
    or die "Unknown test '$test'";
[download]