It seems like you're wanting a symbolic reference to refer to a lexical scalar (a my variable), which it can't directly. If, instead of 'my' you were using 'our', you could use the symbolic reference:

perl -E 'our $p = sub { 1 }; my $q = "p"; say $$q->();'
[download]

...but then your 'our' variable is a package global, and you're mucking around in the symbol table, which may be counterindicated for maintainability.

Couldn't this problem be solved with real refs and a hash table used as a dispatch table?

perl -E 'my %dispatch = ( p => sub { 1 } ); my $q = "p"; say $dispatch
+{$q}->();'
[download]

Hi Dave

> It seems like you're wanting a symbolic reference to refer to a lexical scalar (a my variable), which it can't directly.

indeed... from perlref

Only package variables (globals, even if localized) are visible to symbolic references. Lexical variables (declared with my()) aren’t in a symbol table, and thus are invisible to this mechanism.

It never occurred to me, thanks for pointing it out! =)

Cheers Rolf

( addicted to the Perl Programming Language)

use warnings;
use strict;


my $_parse_element_configuration =
  sub{
    print "element_configuration: @_\n"
  };

my $handler = "_parse_element_configuration";

my $self=42;



#--- dispatch table

my %parser;
$parser{_parse_element_configuration}=$_parse_element_configuration;

my $meth=$parser{$handler};
$self->$meth(666);


#--- lex sym ref via eval

$meth= eval "\$$handler";
$self->$meth(777);


#--- abstracted

sub handle {
  my $name=shift;
  return eval "\$$name";
}

handle($handler)->($self,888);
[download]

element_configuration: 42 666
element_configuration: 42 777
element_configuration: 42 888
[download]

corrected c&p problem but created duplicate! :-(

#--- dispatch table
...
$self->$meth(666);
...
#--- lex sym ref via eval
...
$self->$meth(777);
[download]

Don't both of these approaches take the interpreter on a useless (if there is no '42' package/class) or potentially bugilicious (if there is such a package and it contains a  _whatever method) run time search through the  @ISA tree? Why use the  -> operator to pass an ordinary (i.e., non-class/object reference) parameter? Only
    #--- abstracted
    ...
    handle($handler)->($self,888);
avoids this possibly lengthy detour, but substitutes eval work at runtime.

Of course, I'm not sure how one would create a '42' package in the first place, but what if it had been  $self = 'Foo'; in your example?

Hey AnomalousMonk

none of this methods will ever see @ISA. :)

see also Autoboxing ... "Yes We Can" ( or how I learned to love TIMTOWTDI ;)

42 is just a dummy object, I was too lazy to fake a class for this little demo.

Cheers Rolf

( addicted to the Perl Programming Language)

Hi there,
thanks for your replies.

I have tried the third approach by Lanx, but the program returns the following error:

Variable "$_parse_element_configuration" is not available at (eval 8) 
+line 2.
Use of uninitialized value in subroutine entry at Configuration.pm lin
+e 64.
[download]

My code is :

my $_parse_element_configuration = sub{ ... }

sub _handler{
  my $function_name = shift;
  eval "\$$function_name";
};

[...]

# invoking the handler
_handler("_parse_element_configuration")->($self, $element);
[download]

Where is the problem?

Kind regards,
s.fox

p.s. my Perl version is 5.10, could it be involved?

> Where is the problem?

My code worked and the code you are showing now will also work.

But maybe you should care to define _handler within the scope of your private $_parse... variables to have a proper closure?

Otherwise Variable "$_parse_element_configuration" is not available at (eval 8) line 2."

Cheers Rolf

( addicted to the Perl Programming Language)

$self->$handler(@arguments);
[download]

$self->$_parse_element_configuration(@arguments);
[download]

You can do:

$self->$handler(@arguments);


This will only work if the anonymous subroutine reference is assigned to  $handle and not the name of the lexical as in the OP.