¿Cómo llamo a un nombre de función que está almacenado en un hash en Perl?

Question

Estoy seguro de que esto está cubierto en la documentación en alguna parte, pero no he podido encontrarlo ... Estoy buscando el azúcar sintáctico que permitirá llamar a un método en una clase cuyo nombre está almacenado en una almohadilla (en contraposición a un simple escalar):

use strict; use warnings; 

package Foo; 
sub foo { print "in foo()\n" } 

package main; 
my %hash = (func => 'foo'); 

Foo->$hash{func}; 

Si copio $hash{func} en una variable escalar primero, entonces yo puedo llamar Foo->$func muy bien ... pero lo que falta para que Foo->$hash{func} a trabajar?

(EDITAR: No me refiero a hacer nada especial al llamar a un método en la clase Foo - esto podría ser un objeto bendito (y en mi código real), simplemente fue más fácil escribir un ejemplo autónomo utilizando un método de clase.)

EDIT 2: Para completar los comentarios a continuación, esto es lo que estoy haciendo en realidad (esto es en una biblioteca de azúcar atributo Moose, creado con Moose::Exporter) :

# adds an accessor to a sibling module 
sub foreignTable 
{ 
    my ($meta, $table, %args) = @_; 

    my $class = 'MyApp::Dir1::Dir2::' . $table; 
    my $dbAccessor = lcfirst $table; 

    eval "require $class" or do { die "Can't load $class: $@" }; 

    $meta->add_attribute(
     $table, 
     is => 'ro', 
     isa => $class, 
     init_arg => undef, # don't allow in constructor 
     lazy => 1, 
     predicate => 'has_' . $table, 
     default => sub { 
      my $this = shift; 
      $this->debug("in builder for $class"); 

      ### here's the line that uses a hash value as the method name 
      my @args = ($args{primaryKey} => $this->${\$args{primaryKey}}); 
      push @args, (_dbObject => $this->_dbObject->$dbAccessor) 
       if $args{fkRelationshipExists}; 

      $this->debug("passing these values to $class -> new: @args"); 
      $class->new(@args); 
     }, 
    ); 
} 

he reemplazado por encima de la línea marcada con esto:

 my $pk_accessor = $this->meta->find_attribute_by_name($args{primaryKey})->get_read_method_ref; 
     my @args = ($args{primaryKey} => $this->$pk_accessor); 

PS. Me acabo de dar cuenta de que esta misma técnica (utilizando la clase meta de Moose para buscar el cifrado en lugar de asumir su convención de nomenclatura) no se puede usar para los predicados, ya que Class::MOP::Attribute no tiene un acceso similar get_predicate_method_ref. :(

Answer 1

Foo->${\$hash{func}}; 

Pero para mayor claridad, probablemente todavía escribo como:

my $method = $hash{func}; 
Foo->$method; 

Answer 2

¿Existe una razón por la que está almacenando nombres de subrutina en lugar de las referencias a codificar?

por ejemplo

use strict; use warnings; 

package Foo; 
sub foo { print "in foo()\n" } 

package main; 
my %hash = (func => \&Foo::foo); 

$hash{func}->(); 

No se le pasa el nombre de la clase, pero si eso es importante para usted , se puede usar algo como

my %hash = (func => sub { return Foo->foo(@_) }); 

Answer 3

¿Ha intentado UNIVERSAL'spuede método? Usted debe ser capaz de implementar algo como esto:

## untested 
if (my $code = $object->can($hash{func})) { 
    $object->$code(); 
} 

hice un inútil, ejemplo de una línea de demostrar:

perl -MData::Dumper -le 'my %h = (f => "Dump"); my $o = Data::Dumper->new([qw/1 2 3/]); my $ref = $o->can($h{f}); print $o->$ref()'