NAME

SYNOPSIS

  package Foo;
  use Exporter::Lite;

  our @EXPORT    = qw($This That);      # default exports
  our @EXPORT_OK = qw(@Left %Right);    # optional exports

Then in code using the module:

  use Foo;
  # $This and &That are imported here

You have to explicitly ask for optional exports:

 use Foo qw/ @Left %Right /;

DESCRIPTION

Exporter::Lite simply exports its import() function into your namespace. This might be called a "mix-in" or a "role".

When "Exporter::Lite" was written, if you wanted to use "Exporter" you had to write something like this:

 use Exporter;
 our @ISA = qw/ Exporter /;

"Exporter::Lite" saved you from writing that second line. But since before 2010 you've been able to write:

 use Exporter qw/ import /;

Which imports the "import" function into your namespace from "Exporter". As a result, I would recommend that you use "Exporter" now, as it's a core module (shipped with Perl).

To make sure you get a version of "Exporter" that supports the above usage, specify a minimum version when you "use" it:

 use Exporter 5.57 qw/ import /;

    package My::Module;
    use Exporter::Lite;

    our @EXPORT = qw($Foo bar);

    package My::Module;
    use Exporter::Lite;

    our @EXPORT_OK = qw($Foo bar);

    use My::Module qw($Foo bar);

    package Games;
    our @EXPORT    = qw/ pacman defender  /;
    our @EXPORT_OK = qw/ galaga centipede /;

    use Games qw/ pacman galaga /;

Methods

In normal usage you don't have to worry about this at all.

import

  Some::Module->import;
  Some::Module->import(@symbols);
    

Works just like "Exporter::import()" excepting it only honors @Some::Module::EXPORT and @Some::Module::EXPORT_OK.

The given @symbols are exported to the current package provided they are in @Some::Module::EXPORT or @Some::Module::EXPORT_OK. Otherwise an exception is thrown (ie. the program dies).

If @symbols is not given, everything in @Some::Module::EXPORT is exported.

DIAGNOSTICS

'"%s" is not exported by the %s module'

Attempted to import a symbol which is not in @EXPORT or @EXPORT_OK.

'Can\'t export symbol: %s'

Attempted to import a symbol of an unknown type (ie. the leading $@% salad wasn't recognized).

SEE ALSO

Attribute::Exporter defines attributes which you use to mark which subs and variables you want to export, and how.

Exporter::Simple also uses attributes to control the export of functions and variables from your module.

Const::Exporter makes it easy to create a module that exports constants.

Constant::Exporter is another module that makes it easy to create modules that define and export constants.

Sub::Exporter is a "sophisticated exporter for custom-built routines"; it lets you provide generators that can be used to customise what gets imported when someone uses your module.

Exporter::Tiny provides the same features as Sub::Exporter, but relying only on core dependencies.

Exporter::Shiny is a shortcut for Exporter::Tiny that provides a more concise notation for providing optional exports.

Exporter::Declare provides syntactic sugar to make the export status of your functions part of their declaration. Kind of.

AppConfig::Exporter lets you export part of an AppConfig-based configuration.

Exporter::Lexical lets you export lexical subs from your module.

Constant::Export::Lazy lets you write a module that exports function-style constants, which are instantiated lazily.

Exporter::Auto will export everything from your module that it thinks is a public function (name doesn't start with an underscore).

Class::Exporter lets you export class methods as regular subroutines.

Xporter is like Exporter, but with persistent defaults and auto-ISA.

REPOSITORY

AUTHORS

LICENSE

See http://www.perl.com/perl/misc/Artistic.html