package pmsopw_249244;

sub import {
  push @pmsopw_249244::USES, [scalar caller, @_[1 .. $#_]];
}
sub real_import {
  $_->() for @_[1 .. $#_];
}

INIT {
  for (@pmsopw_249244::USES) {
    my($pkg, @args) = @$_;
    eval (qq[{
      package $pkg;
      pmsopw_249244->real_import(\@args);
    }]);
    warn "ack - $@" if $@;
  }
}

q{ the end is nigh ...};
[download]

use pmsopw_249244 (\&func);

sub func {
  print "I've been called\n";
}

__output__

I've been called
[download]

_________
broquaint

That works fine. You can take a reference to a subroutine by name before the subroutine exists. Perl does some interesting tricks to allow this. The problem you will run into is if you want to dereference it while still inside of import().

I can think of several ways around this. The very straight-forward:

    require Alzabo::MethodMaker;
    Alzabo::MethodMaker->import( name_maker => \@name_maker );
[download]

    package Alzabo::MethodMaker;
    sub import {
        ...
    }
    \&import;
[download]

    (require Alzabo::MethodMaker)->(
        name_maker => \&name_maker,
    );
[download]

    use Alzabo::MethodMaker(
        name_maker => sub {
            ...
        },
    );
[download]

That might be the most appealing solution because it hides so much from the module user so be sure to carefully document when the modules actually get "made" if you go this route.

You could export a routine that makes the methods:

    use Alzabo::MethodMaker qw( makeMethods );
    makeMethods(
        name_maker => \&name_maker,
    );
[download]

In any case, good luck.

Putting the subs you need (that is baz) in a module of theire own and useing this before using alzabo isn't an option? Or using an anonymous sub?

Or am I just plain silly?

regards,
tomte

Hlade's Law:

If you have a difficult task, give it to a lazy person --
they will find an easier way to do it.

The real problem isn't that the subroutine reference is taken before it exists, as this actually works due to the magic of Perl:

package A;
sub import { *b = $_[1] };
BEGIN { $INC{"A.pm"} = undef }  # Stop 'use' from loading A.pm

package main;
use A \&c;
print A::b(), "\n";   # prints "YO\n"
sub c { "YO" }
[download]

I suspect your problem is that Alzabo::MethodMaker is trying to execute name_maker() before it is defined (otherwise, you wouldn't have this question, as the above code should 'work'). The only way around this is to define name_maker() first, or to delay execution of Alzabo::MethodMaker::import using one of the means suggested by other people.

I'd like to be clear here that Alzabo::MethodMaker is only an example and that I intended to ask for ideas for handling this problem in the general case.

I think I was clear that in the general case, as long as the subroutine is not invoked as part of the 'use', there is no problem. If the subroutine is invoked, then it needs to have already been defined. Only taking the reference of an as-yet-non-existent subroutine is not dangerous.

Actually, there is one danger, and it has to do with prototypes. If the prototypes differ (when the function actually is defined), Perl will croak.

Actually, while working on Exporter::VA I discovered that it does in fact work. Taking the reference early defines a place-holder for it, and later defining it fills in that place holder. Taking a reference to the thing after it's been defined properly gives the same reference as taking such a reference "too early".

BEGIN { print \&baz, "\n" }
sub baz {}
print \&baz;
[download]

I do exactly that in Exporter::VA. The import function can see a ref as a parameter, even though the implicit BEGIN block is causing this to run before the thing exists. To make this work well, at import() time it only remembers the reference, and does not try to update the contents (its changes will be clobbered by your initialization later) or rely on it being set-up just yet. Later, a function that import() put into my package is executed, and it can refer to that reference now.

So, you need to make your use statement just set-up, and "commit" the action later. In this case, sticking an END block into the calling package might do the trick.

—John

Are you going to need the procedure anymore or is it just for this use statement? If it's just to the use you can do it like this:

use Alzabo::MethodMaker(
    schema => 'greenpartydb',
    class_root => 'GreenPartyDB::Database',
    all => 1,
    name_maker => sub {
      ....
    }
);
[download]

Jenda
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.
   -- Rick Osborne

Edit by castaway: Closed small tag in signature

Wouldn't a simple pre-declaration in a BEGIN block solve the problem?

You could even put this with or inside the subroutine body to keep things together.

#! perl -slw
use Try qw[ \&callback ];

sub callback{
    BEGIN{ sub callback; }
    #do stuff
}
[download]

Wouldn't a simple pre-declaration in a BEGIN block solve the problem?

Nope as the sub still has to be parsed e.g

BEGIN {
  foo();
}

sub foo {
  BEGIN { sub foo }
  print "in foo()";
}

__output__

Undefined subroutine &main::foo called at 249927.pl line 2.
BEGIN failed--compilation aborted at 249927.pl line 3.
[download]

So you need to delay the execution of the coderef until after compile-time unless you can force the compilation of the given sub.
HTH

_________
broquaint

Right. I brainfarted again.

---

Examine what is said, not who speaks.
1) When a distinguished but elderly scientist states that something is possible, he is almost certainly right. When he states that something is impossible, he is very probably wrong.
2) The only way of discovering the limits of the possible is to venture a little way past them into the impossible
3) Any sufficiently advanced technology is indistinguishable from magic.
Arthur C. Clarke.