Dynamically constructed function calls

[WalruZ]

I'm stupid.

I'm trying to dynamically construct a call to an autoloaded function of a class. The class isn't in my control. I can't come up with the right syntax for the line below the comment in the supplied non-functional example. It looks like it does because I have been flailing.

#!/usr/bin/perl

use strict;

my %vars = ( 'user_login'         => { req =>  1 },
             'user_passwd'        => { req =>  1 },
             'user_display'       => { req =>  0 },
           );

my $f = Foo->new();

while ( (my ($key,$atr)) = (each %vars))
{
  print "$key, $atr\n";

  # eg, trying to construct and call autoloaded
  # $f->prefix_user_login method.

  &$f->"prefix_$key"( $atr);
}


package Foo;

sub new       { return bless( { }, shift); }

sub AUTOLOAD  { 
     use vars '$AUTOLOAD'; 
     print "autoloaded method: $AUTOLOAD \n"; 
}

sub DESTROY   {}

I genuflect.

[ikegami]

There's no need for eval here.

my $method = "prefix_$key";
$f->$method($atr);

[itub]

From perldoc perlop

Otherwise, the right side is a method name or a simple scalar variable containing either the method name or a subroutine reference, and the left side must be either an object (a blessed reference) or a class name (that is, a package name). See perlobj.

This means that you can't have a string or an expression as a method name. It has to be a simple scalar. So if you do the following, everything should work fine:

my $method = "prefix_$key";
$f->$method($atr);

[dpuu]

It has to be a scalar, but it doesn't need to be a variable. You can say

  $f->${\("prefix_$key")}($atr);

However, using a variable is probably clearer.

Update: added the missing '$' pointed out by ikegami

[ysth]

I've toyed with the idea of making $object->do {expression-yielding-method-name} work. Right now it gives a syntax error.

Of course, you can do something pretty close by just having a do method:

sub foo { print "in foo" }
sub do {
   my $self = shift;
   my $meth = shift;
   $self->$meth(@_)
}

$object->do("foo", @args);

[ikegami]

You're missing a $. It should be $f->${\("prefix_$key")}($atr);

[itub]

Nice trick, I had never thought about that! :-)

[BrowserUk]

while ( (my ($key,$atr)) = (each %vars))
{
  print "$key, $atr\n";

  my $method = "prefix_$key";
  $f->$method( $atr );
}

[Anonymous Monk]

Just check if you can call it

$f->can("prefix_$key")->( $atr );

anon-broquaint

[tall_man]

That doesn't work. $f->can returns a false value, and then you get the message:

Can't use string ("") as a subroutine ref while "strict refs" in use a
+t autol.pl line 21.

Update:In the pod for UNIVERSAL.pm, it says:

"can" cannot know whether an object will be able to provide a method through AUTOLOAD, so a return value of undef does not necessarily mean the object will not be able to handle the method call.

[revdiablo]

That doesn't work.

It doesn't work with UNIVERSAL::can, but it could work with an overloaded can:

{
    package Foo;
    my %meth = (
        foo => sub { print "Foo?\n" },
        bar => sub { print "Bar!\n" },
    );
    sub baz {
        print "Baz.\n";
    }
    sub can {
        $meth{$_[1]} || __PACKAGE__->UNIVERSAL::can($_[1])
    }
    sub AUTOLOAD {
        use vars '$AUTOLOAD';
        (my $methname = $AUTOLOAD) =~ s/.*:://;
        $meth{$methname}->(@_);
    }
}

for (qw(foo bar baz qux)) {
    if (my $cr = Foo->can($_)) {
        $cr->();
    } else {
        print "Cannot $_\n";
    }
}

[dragonchild]

Surely, you mean

$f->can("prefix_$key")->( $f, $atr );

[BrowserUk]

anon-broquaint

Why?