=over =item use Module VERSION LIST =item use Module VERSION =item use Module LIST =item use Module =item 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 I be a bareword. VERSION, which can be specified as a literal of the form v5.6.1, demands that the current version of Perl (C<$^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 L, 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 Cing 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 C forces the C and C to happen at compile time. The C makes sure the module is loaded into memory if it hasn't been yet. The C is not a builtin--it's just an ordinary static method call into the C package to tell the module to import the list of features back into the current package. The module can implement its C method any way it likes, though most modules just choose to derive their C method via inheritance from the C class that is defined in the C module. See L. If no C method can be found then the call is skipped. If you do not want to call the package's C method (for instance, to stop your namespace from being altered), explicitly supply the empty list: use Module (); That is exactly equivalent to BEGIN { require Module } If the VERSION argument is present between Module and LIST, then the C 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 C<$Module::VERSION>. Again, there is a distinction between omitting LIST (C called with no arguments) and an explicit empty LIST C<()> (C 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 constant; use diagnostics; use integer; 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 C or C, unlike ordinary modules, which import symbols into the current package (which are effective through the end of the file). There's a corresponding C command that unimports meanings imported by C, i.e., it calls C instead of C. no integer; no strict 'refs'; no warnings; If no C method can be found the call fails with a fatal error. See L for a list of standard modules and pragmas. See L for the C<-M> and C<-m> command-line options to perl that give C functionality from the command-line. =back