Re^2: How to conditionally execute a subroutine defined as hash value

[Anonymous Monk]

Thanks, but if I have to pass some parameters to the call like this?

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";
}

[BrowserUk]

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}();

[derby]

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 );

[BrowserUk]

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.

[Anonymous Monk]

Thanks a lot!

[Corion]

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);

When taking the reference, you should never use parentheses.

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

[Anonymous Monk]

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

[Corion]

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

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

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'";