our $Debug = 0;
our $ExportLevel = 0;
our $Verbose ||= 0;
-our $VERSION = '5.566';
-$Carp::Internal{Exporter} = 1;
+our $VERSION = '5.59';
+our (%Cache);
+# Carp does this now for us, so we can finally live w/o Carp
+#$Carp::Internal{Exporter} = 1;
sub as_heavy {
require Exporter::Heavy;
my $pkg = shift;
my $callpkg = caller($ExportLevel);
+ if ($pkg eq "Exporter" and @_ and $_[0] eq "import") {
+ *{$callpkg."::import"} = \&import;
+ return;
+ }
+
# We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-(
- my($exports, $export_cache, $fail)
- = (\@{"$pkg\::EXPORT"}, \%{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"});
+ my($exports, $fail) = (\@{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"});
return export $pkg, $callpkg, @_
if $Verbose or $Debug or @$fail > 1;
+ my $export_cache = ($Cache{$pkg} ||= {});
my $args = @_ or @_ = @$exports;
local $_;
=head1 SYNOPSIS
-In module ModuleName.pm:
+In module YourModule.pm:
- package ModuleName;
+ package YourModule;
require Exporter;
@ISA = qw(Exporter);
+ @EXPORT_OK = qw(munge frobnicate); # symbols to export on request
- @EXPORT = qw(...); # symbols to export by default
- @EXPORT_OK = qw(...); # symbols to export on request
- %EXPORT_TAGS = tag => [...]; # define names for sets of symbols
-
-In other files which wish to use ModuleName:
+or
- use ModuleName; # import default symbols into my package
+ package YourModule;
+ use Exporter 'import'; # gives you Exporter's import() method directly
+ @EXPORT_OK = qw(munge frobnicate); # symbols to export on request
- use ModuleName qw(...); # import listed symbols into my package
+In other files which wish to use YourModule:
- use ModuleName (); # do not import any symbols
+ use ModuleName qw(frobnicate); # import listed symbols
+ frobnicate ($left, $right) # calls YourModule::frobnicate
=head1 DESCRIPTION
-The Exporter module implements a default C<import> method which
-many modules choose to inherit rather than implement their own.
+The Exporter module implements an C<import> method which allows a module
+to export functions and variables to its users' namespaces. Many modules
+use Exporter rather than implementing their own C<import> method because
+Exporter provides a highly flexible interface, with an implementation optimised
+for the common case.
Perl automatically calls the C<import> method when processing a
C<use> statement for a module. Modules and C<use> are documented
@EXPORT = qw(afunc $scalar @array); # afunc is a function
@EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc
+If you are only exporting function names it is recommended to omit the
+ampersand, as the implementation is faster this way.
+
=head2 Selecting What To Export
Do B<not> export method names!
As a general rule, if the module is trying to be object oriented
then export nothing. If it's just a collection of functions then
-@EXPORT_OK anything but use @EXPORT with caution.
+@EXPORT_OK anything but use @EXPORT with caution. For function and
+method names use barewords in preference to names prefixed with
+ampersands for the export lists.
Other module design guidelines can be found in L<perlmod>.
+=head2 How to Import
+
+In other files which wish to use your module there are three basic ways for
+them to load your module and import its symbols:
+
+=over 4
+
+=item C<use ModuleName;>
+
+This imports all the symbols from ModuleName's @EXPORT into the namespace
+of the C<use> statement.
+
+=item C<use ModuleName ();>
+
+This causes perl to load your module but does not import any symbols.
+
+=item C<use ModuleName qw(...);>
+
+This imports only the symbols listed by the caller into their namespace.
+All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error
+occurs. The advanced export features of Exporter are accessed like this,
+but with list entries that are syntactically distinct from symbol names.
+
+=back
+
+Unless you want to use its advanced features, this is probably all you
+need to know to use Exporter.
+
+=head1 Advanced features
+
=head2 Specialised Import Lists
-If the first entry in an import list begins with !, : or / then the
-list is treated as a series of specifications which either add to or
-delete from the list of names to import. They are processed left to
+If any of the entries in an import list begins with !, : or / then
+the list is treated as a series of specifications which either add to
+or delete from the list of names to import. They are processed left to
right. Specifications are in the form:
[!]name This name only
specifications are being processed and what is actually being imported
into modules.
-=head2 Exporting without using Export's import method
+=head2 Exporting without using Exporter's import method
Exporter has a special method, 'export_to_level' which is used in situations
-where you can't directly call Export's import method. The export_to_level
+where you can't directly call Exporter's import method. The export_to_level
method looks like:
-MyPackage->export_to_level($where_to_export, $package, @what_to_export);
+ MyPackage->export_to_level($where_to_export, $package, @what_to_export);
where $where_to_export is an integer telling how far up the calling stack
to export your symbols, and @what_to_export is an array telling what
For example, suppose that you have a module, A, which already has an
import function:
-package A;
+ package A;
-@ISA = qw(Exporter);
-@EXPORT_OK = qw ($b);
+ @ISA = qw(Exporter);
+ @EXPORT_OK = qw ($b);
-sub import
-{
- $A::b = 1; # not a very useful import method
-}
+ sub import
+ {
+ $A::b = 1; # not a very useful import method
+ }
and you want to Export symbol $A::b back to the module that called
package A. Since Exporter relies on the import method to work, via
inheritance, as it stands Exporter::import() will never get called.
Instead, say the following:
-package A;
-@ISA = qw(Exporter);
-@EXPORT_OK = qw ($b);
+ package A;
+ @ISA = qw(Exporter);
+ @EXPORT_OK = qw ($b);
-sub import
-{
- $A::b = 1;
- A->export_to_level(1, @_);
-}
+ sub import
+ {
+ $A::b = 1;
+ A->export_to_level(1, @_);
+ }
This will export the symbols one level 'above' the current package - ie: to
the program or module that used package A.
-Note: Be careful not to modify '@_' at all before you call export_to_level
+Note: Be careful not to modify C<@_> at all before you call export_to_level
- or people using your package will get very unexplained results!
+=head2 Exporting without inheriting from Exporter
+
+By including Exporter in your @ISA you inherit an Exporter's import() method
+but you also inherit several other helper methods which you probably don't
+want. To avoid this you can do
+
+ package YourModule;
+ use Exporter qw( import );
+
+which will export Exporter's own import() method into YourModule.
+Everything will work as before but you won't need to include Exporter in
+@YourModule::ISA.
=head2 Module Version Checking
https://perl5.git.perl.org / perl5.git / blobdiff