At some point in their life, every programmer decides that, for the problem at hand, the best solution is to create a set of functions and pass their names as variables. It's not.
First, its a security hazard, as users' input should never be used to execute code in your programs. Second, since code doesn't write itself, the functions themselves have to be written and named, so the actual "variable named after function/function named after variable" scheme isn't much different than foo() if (/foo/).
This pseudo-"functional programming" is better written as a hash with the variable name as key and a function ref as value, similar (but not limited) to this example:

use strict;
use warnings;

my %hash = (
    foo => sub {return "foo\n"},
    bar => sub {return "bar\n"},
);

print &{$hash{'foo'}};
[download]

I saw the root node's title and the number of replies and without even looking at the content figured people were demonstrating lots of different ways to do dispatch tables. Then actually reading the thread, I saw no dispatch tables at all, until the very last reply, by Erez.

Better late than never :)

If (as I guess from the OP's update) the subs do more than one-line of work, you can still use a dispatch table, but arranged like:

sub foo { ... }
sub bar { ... }
my %hash = (
    foo => \&foo,
    bar => \&bar,
);

$var = "foo";
&{$hash{$var}}(@args);
[download]

--
Online Fortune Cookie Search

my $ref = do { no strict 'refs'; \&$var };
$ref->();
[download]

There's usually better ways of achieving one's goals. We could help you better if we knew what you were actually trying to do.

There's usually better ways of achieving one's goals. We could help you better if we knew what you were actually trying to do.

I have used symbolic references to simulate linked lists. For example:

sub _create_node
  {
    my ($node,$parent,$node_info) = @_;
    no strict;
    @{$node}{qw/parent info/} = ($parent,$node_info);
  }
[download]

This way, each node is a hash with the name of its parent under the key "parent" and the info related to the node under the key "node_info". To go through a node:

sub go_through
  {
    no strict 'refs';
    my ($self, $node) = @_;
    return "" unless defined ${$node}{"info"};
    my @info_nodes;
    while (${$node}{"info"} ne "root"){
      push @info_nodes, (${$node}{"info"});
      $node = ${$node}{"parent"};
    }
    return \@info_nodes;
  }
[download]

This runs very fast and doesn't need too much memory

citromatik

Except that's not a symbolic reference. That's a hash-reference and your code is more commonly written as:

sub go_through {
    my ($self, $node) = @_;
    return unless defined $node->{info};

    my @info_nodes;
    while ( $node->{info} ne 'root' ) {
        push @info_nodes, $node->{info};
        $node = $node->{parent};
    }

    return \@info_nodes;
}
[download]

This version also fixes a bug you had in your original code regarding contexts.

---

My criteria for good software:

1. Does it work?
2. Can someone else come in, make a change, and be reasonably certain no bugs were introduced?

What you are trying to do is called a symbolic reference and needs to be done without reference strict-ness, see perlref for more details

use strict;
use warnings;

sub foo {  print "foo\n"; }
sub bar {  print "bar\n"; }

my $var = 'foo';
no strict 'refs';
&$var;  ## <-
[download]

Hope this helps

citromatik

[ You asked me to comment on your update. It was a while ago, so I hope this is still useful to you. ]

This sounds like the perfect situation for a dispatch table.

# Setup

my %validators = (
   is_int             => \&is_int,
   is_string          => \&is_string,
   is_yyyy_mm_dd_date => \&is_yyyy_mm_dd_date,
);


# Load configuration

my @validators;
while (<$config_fh>) {                              # Or whatever
   my ($col, $validator_name) = /^col(\d+)=(\w+)$/  #
      or die;

   exists( $validators{$validator_name} )
      or die;
   
   $validators[$col] = $validators{$validator_name};
}


# Process data.

my $csv = Text::CSV->new(sep_char => ';');

while (<$data_fh>) {
   $csv->parse($_)
      or die;

   my @fields = $csv->fields();

   for my $i ( 0..$#validators ) {
      my $validator = $validators[$i];
      next if !defined( $validator );

      $validator->($fields[$i])
         or die;
   }
}
[download]

One approach would be to build an array  @col_validators in which each element of the array holds a reference to the validation function for the corresponding column of the data record; e.g., from the example you have given in your question, element 1 of the array holds a reference to the  is_int() integer data validation function.

This array would be built when the configuration file is parsed: as each config statement is parsed, the array is checked to see that a validation function has not been assigned to that column already, that the validation function exists, etc.; the function reference specified in the config statement is then assigned to the specified array element.

After the array is built, it should be checked to see that no empty slots exist or that any empty slots are filled with a reference to a null or error-reporting function.

When the array is used, it only remains the check that a column parsed from a record corresponds to an existing element in the validation array (if it does not, the record itself may be invalid), and you're done.

BTW -- Since your updated question is differs significantly from the original, a re-post seems warranted.