use autouse 'Carp' => qw(carp croak); carp "this carp was predeclared and autoused";
This pragma provides a mechanism for run-time demand
loading of a particular module only when a function from that module
really gets called. It does this by providing a stub function that
replaces itself with the real call once triggered. This is similar in
spirit to the way the standard AutoLoader
and
SelfLoader
modules behave. In short, it's a
performance hack to help make your Perl program start up faster (on
average) by avoiding compilation of modules that might never ever be
called during a given execution run.
How autouse
behaves depends on whether the
module is already loaded. For example, if the module
Module
is already loaded, then the
declaration:
use autouse 'Module' => qw(func1 func2($;$) Module::func3);
is equivalent to the simple import of two functions:
use Module qw(func1 func2);
This assumes that Module
defines
func2()
with prototype ($;$)
,
and that func1()
and func3()
have no prototypes. (More generally, this also assumes that
Module
uses Exporter
's standard
import
method; otherwise, a fatal error is raised.)
In any event, it completely ignores Module::func3
since that is presumably already declared.
If, on the other hand, Module
has not yet
been loaded when the autouse
pragma is parsed, the
pragma declares functions func1
and
func2
to be in the current package. It also
declares a function Module::func3
(which could be
construed as mildly antisocial, were it not for the fact that the
nonexistence of the Module
module has even more
antisocial consequences). When these functions are called, they make
sure the Module
in question is loaded and then
replace themselves with calls to the real functions just
loaded.
Because the autouse
pragma moves portions of
your program's execution from compile time to run time, this can have
unpleasant ramifications. For example, if the module you
autouse
has some initialization that is expected to
be done early, this may not happen early enough. Autousing can also
hide bugs in your code when important checks are moved from compile
time to run time.
In particular, if the prototype you've specified on
autouse
line is wrong, you will not find out about
it until the corresponding function is executed (which may be months
or years later, for a rarely called function). To partially alleviate
this problem, you could write your code like this during code
development:
use Chase; use autouse Chase => qw(hue($) cry(&$)); cry "this cry was predeclared and autoused";
The first line ensures that errors in your argument
specification will be found early. When your program graduates from
development into production mode, you can comment out the regular
loading of the Chase
module and leave just the
autousing call in place. That way you get safety during development
and performance during production.