VERSION may be either a numeric argument such as 5.006, which will be
compared to $]
, or a literal of the form v5.6.1, which will be compared
to $^V
(aka $PERL_VERSION. A fatal error is produced if VERSION is
greater than the version of the current Perl interpreter; Perl will not
attempt to parse the rest of the file. Compare with require, which can
do a similar check at run time.

Specifying VERSION as a literal of the form v5.6.1 should generally be
avoided, because it leads to misleading error messages under earlier
versions of Perl which do not support this syntax. The equivalent numeric
version should be used instead.

This is often useful if you need to check the current Perl version before
useing 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 Exporter. If no import
method can be found then the call is skipped.

If you do not want to call the package's import method (for instance,
to stop your namespace from being altered), explicitly supply the empty list:

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:

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.