deferred - Defer loading of modules until methods are called


  use deferred "SomeModule";
  use SomeModule;

  # Module not yet loaded, but you don't have to worry about conditionally
  # loading it.
  my $foo = SomeModule->new; # Module now loaded


For modules where you don't care about the ->import method being called, such as pure OO modules you may not want to load the module until it is actually used. (The main reason being to save time or memory.)

You should be very careful if considering using this on code not under your control, please understand this may break assumptions the code makes (that are quite valid in normal circumstances).


The interface to this module is via arguments to use deferred.

Either a string or a regexp reference (qr//) may be provided. A string will be interpreted as a regular expression matching the full module name (i.e. ^ and $ are prepended and appended respectively).

For example:

  use deferred "Foo::.*"; # Defer loading all modules under the Foo namespace

  use deferred "Bar", qr/Baz/; # Defer loading

use statements executed after a use deferred statement will be checked to see if loading of that module should be deferred, if so the module will not be loaded until a method is called on that module name.

Multiple use deferred statements will add to the list of matches.

This is not currently a pragma, so it is not lexically scoped.


no deferred will disable deferred loading from that point onwards. It will load all deferred modules at the moment it is called, unless -discard is provided as an argument.

  no deferred; # Disable all deferred loading, load modules

  no deferred -discard; # Disable all deferred loading, discard list

An argument may be provided to stop future deferred loads of a previously specified item:

  no deferred "Foo::.*";

If an argument is provided no modules will be loaded.


This module certainly is a case of providing enough ammo to shoot yourself in the foot several times over. Deferring the loading of modules such as base and parent will almost certainly result in confusion. (The module itself tries to handle some of these issues, but it can't cope with some cases).

Combining this module with other modules that make use of code references in @INC may or may not work, potentially dependant on order of loading. This module places its code reference onto the start of @INC when loaded. (Particular modules -- that don't live in the Acme namespace -- to be aware of are everywhere and App::FatPacker.)

In order for this to work your use statements must exactly match the classes you call methods on (i.e. with some modules it is common practice to use a high level module such as Foo, then create an instance of Foo::Bar -- this won't work).

This module also rudely hijacks UNIVERSAL::AUTOLOAD.


Class::Autouse - I tried this, I actually wanted something between its superloader and manually specifying classes. I think it handles more edge cases though.


This program is free software. It comes without any warranty, to the extent permitted by applicable law. You can redistribute it and/or modify it under the terms of the Do What The Fuck You Want To Public License, Version 2, as published by Sam Hocevar. See or Software::License::WTFPL_2 for more details.


David Leadbeater <>, 2010