Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Contact Us
Online Help
Domain Status
Man Pages

Virtual Servers

Topology Map

Server Agreement
Year 2038

USA Flag



Man Pages

Manual Reference Pages  -  MODULE::LOAD (3)

.ds Aq ’


Module::Load - runtime require of both modules and files



  use Module::Load;

  my $module = Data::Dumper;

  load Data::Dumper;     # loads that module, but not import any functions
                         # -> cannot use Dumper function

  load Data::Dumper;   # ditto
  load $module           # tritto

  autoload Data::Dumper; # loads that module and imports the default functions
                         # -> can use Dumper function

  my $script = some/
  load $script;
  load some/;  # use quotes because of punctuations

  load thing;             # try thing first, then

  load CGI, :all;       # like use CGI qw[:standard]


Module::Load eliminates the need to know whether you are trying to require either a file or a module.

If you consult perldoc -f require you will see that require will behave differently when given a bareword or a string.

In the case of a string, require assumes you are wanting to load a file. But in the case of a bareword, it assumes you mean a module.

This gives nasty overhead when you are trying to dynamically require modules at runtime, since you will need to change the module notation (Acme::Comment) to a file notation fitting the particular platform you are on.

Module::Load eliminates the need for this overhead and will just DWYM.

Difference between CWload and CWautoload

Module::Load imports the two functions - load and autoload

autoload imports the default functions automatically, but load do not import any functions.

autoload is usable under BEGIN{};.

Both the functions can import the functions that are specified.

Following codes are same.

  load File::Spec::Functions, qw/splitpath/;

  autoload File::Spec::Functions, qw/splitpath/;


load Loads a specified module.

See Rules for detailed loading rule.

autoload Loads a specified module and imports the default functions.

Except importing the functions, ’autoload’ is same as ’load’.

load_remote Loads a specified module to the specified package.

  use Module::Load load_remote;

  my $pkg = Other::Package;

  load_remote $pkg, Data::Dumper; # load a module to Other::Package
                                    # but do not import Dumper function

A module for loading must be quoted.

Except specifing the package and quoting module name, ’load_remote’ is same as ’load’.

autoload_remote Loads a specified module and imports the default functions to the specified package.

  use Module::Load autoload_remote;

  my $pkg = Other::Package;

  autoload_remote $pkg, Data::Dumper; # load a module to Other::Package
                                        # and imports Dumper function

A module for loading must be quoted.

Except specifing the package and quoting module name, ’autoload_remote’ is same as ’load_remote’.


All functions have the following rules to decide what it thinks you want:
o If the argument has any characters in it other than those matching \w, : or , it must be a file
o If the argument matches only [\w:], it must be a module
o If the argument matches only \w, it could either be a module or a file. We will try to find first in @INC and if that fails, we will try to find file in @INC. If both fail, we die with the respective error messages.


’load’ and ’autoload’ are imported by default, but ’load_remote’ and ’autoload_remote’ are not imported.

To use ’load_remote’ or ’autoload_remote’, specify at ’use’.
‘‘load’’,‘‘autoload’’,‘‘load_remote’’,‘‘autoload_remote’’ Imports the selected functions.

  # imports load and autoload (default)
  use Module::Load;

  # imports autoload only
  use Module::Load autoload;

  # imports autoload and autoload_remote, but dont import load;
  use Module::Load qw/autoload autoload_remote/;

’all’ Imports all the functions.

  use Module::Load all; # imports load, autoload, load_remote, autoload_remote

’’,’none’,undef Not import any functions (load and autoload are not imported).

  use Module::Load ;

  use Module::Load none;

  use Module::Load undef;


Because of a bug in perl (#19213), at least in version 5.6.1, we have to hardcode the path separator for a require on Win32 to be /, like on Unix rather than the Win32 \. Otherwise perl will not read its own %INC accurately double load files if they are required again, or in the worst case, core dump.

Module::Load cannot do implicit imports, only explicit imports. (in other words, you always have to specify explicitly what you wish to import from a module, even if the functions are in that modules’ @EXPORT)


Thanks to Jonas B. Nielsen for making explicit imports work.


Please report bugs or other issues to <<gt>.


This module by Jos Boumans <>.


This library is free software; you may redistribute and/or modify it under the same terms as Perl itself.
Search for    or go to Top of page |  Section 3 |  Main Index

perl v5.20.3 MODULE::LOAD (3) 2014-02-20

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.