Perl5 リファレンス

       use Module VERSION LIST

       use Module VERSION

       use Module LIST

       use Module

       use VERSION
               Imports some semantics into the current package
               from the named module, generally by aliasing
               certain subroutine or variable names into your
               package.  It is exactly equivalent to

                   BEGIN { require Module; import Module LIST; }

               except that Module must be a bareword.

               VERSION, which can be specified as a literal of
               the form v5.6.1, demands that the current version
               of Perl (`$^V' or $PERL_VERSION) be at least as
               recent as that version.  (For compatibility with
               older versions of Perl, a numeric literal will
               also be interpreted as VERSION.)  If the version
               of the running Perl interpreter is less than
               VERSION, then an error message is printed and Perl
               exits immediately without attempting to parse the
               rest of the file.  Compare with the require entry
               elsewhere in this document, which can do a similar
               check at run time.

                   use v5.6.1;         # compile time version check
                   use 5.6.1;          # ditto
                   use 5.005_03;       # float version allowed for compatibility

               This is often useful if you need to check the
               current Perl version before `use'ing library
               modules that have changed in incompatible ways
               from older versions of Perl.  (We try not to do
               this more than we have to.)

               The `BEGIN' forces the `require' and `import' to
               happen at compile time.  The `require' makes sure
               the module is loaded into memory if it hasn't been
               yet.  The `import' is not a builtin--it's just an
               ordinary static method call into the `Module'
               package to tell the module to import the list of
               features back into the current package.  The
               module can implement its `import' method any way
               it likes, though most modules just choose to
               derive their `import' method via inheritance from
               the `Exporter' class that is defined in the
               `Exporter' module.  See the Exporter manpage.  If
               no `import' method can be found then the call is

               If you don't want your namespace altered,
               explicitly supply an empty list:

                   use Module ();

               That is exactly equivalent to

                   BEGIN { require Module }

               If the VERSION argument is present between Module
               and LIST, then the `use' will call the VERSION
               method in class Module with the given version as
               an argument.  The default VERSION method,
               inherited from the UNIVERSAL class, croaks if the
               given version is larger than the value of the
               variable `$Module::VERSION'.

               Again, there is a distinction between omitting
               LIST (`import' called with no arguments) and an
               explicit empty LIST `()' (`import' not called).
               Note that there is no comma after VERSION!

               Because this is a wide-open interface, pragmas
               (compiler directives) are also implemented this
               way.  Currently implemented pragmas are:

                   use integer;
                   use diagnostics;
                   use sigtrap  qw(SEGV BUS);
                   use strict   qw(subs vars refs);
                   use subs     qw(afunc blurfl);
                   use warnings qw(all);

               Some of these pseudo-modules import semantics into
               the current block scope (like `strict' or
               `integer', unlike ordinary modules, which import
               symbols into the current package (which are
               effective through the end of the file).

               There's a corresponding `no' command that
               unimports meanings imported by `use', i.e., it
               calls `unimport Module LIST' instead of `import'.

                   no integer;
                   no strict 'refs';
                   no warnings;

               If no `unimport' method can be found the call
               fails with a fatal error.

               See the perlmod manpage for a list of standard
               modules and pragmas.