Lexical::Var3pm

Usage

    use Lexical::Var '$foo' => \$Remote::foo;
    use Lexical::Var '$const' => \123;
    use Lexical::Var '@bar' => [];
    use Lexical::Var '%baz' => { a => 1, b => 2 };
    use Lexical::Var '&quux' => sub { $_[0] + 1 };
    use Lexical::Var '*wibble' => Symbol::gensym();

Overview

This module implements lexical scoping of static variables and subroutines. Although it can be used directly, it is mainly intended to be infrastructure for modules that manage namespaces.

This module influences the meaning of single-part variable names that appear directly in code, such as "$foo". Normally, in the absence of any particular declaration, or under the effect of an "our" declaration, this would refer to the scalar variable of that name located in the current package. A "Lexical::Var" declaration can change this to refer to any particular scalar, bypassing the package system entirely. A variable name that includes an explicit package part, such as "$main::foo", always refers to the variable in the specified package, and is unaffected by this module. A symbolic reference through a string value, such as ""${'foo'}"", also looks in the package system, and so is unaffected by this module.

The types of name that can be influenced are scalar ("$foo"), array ("@foo"), hash ("%foo"), subroutine ("&foo"), and glob ("*foo"). A definition for any of these names also affects code that logically refers to the same entity, even when the name is spelled without its usual sigil. For example, any definition of "@foo" affects element references such as "$foo[0]". Barewords in filehandle context actually refer to the glob variable. Bareword references to subroutines, such as "foo(123)", only work on Perl 5.11.2 and later; on earlier Perls you must use the "&" sigil, as in "&foo(123)".

Where a scalar name is defined to refer to a constant (read-only) scalar, references to the constant through the lexical namespace can participate in compile-time constant folding. This can avoid the need to check configuration values (such as whether debugging is enabled) at runtime.

A name definition supplied by this module takes effect from the end of the definition statement up to the end of the immediately enclosing block, except where it is shadowed within a nested block. This is the same lexical scoping that the "my", "our", and "state" keywords supply. Definitions from Lexical::Var and from "my"/"our"/"state" can shadow each other (except that Lexical::Var can't shadow a "my"/"our"/"state" subroutine prior to Perl 5.19.1). These lexical definitions propagate into string "eval"s, on Perl versions that support it (5.9.3 and later).

This module only manages variables of static duration (the kind of duration that "our" and "state" variables have). To get a fresh variable for each invocation of a function, use "my".

Package methods

These methods are meant to be invoked on the "Lexical::Var" package.

Lexical::Var->import(NAME => REF, ...)

Sets up lexical variable declarations, in the lexical environment that is currently compiling. Each NAME must be a variable name (e.g., "$foo") including sigil, and each REF must be a reference to a variable/value of the appropriate type. The name is lexically associated with the referenced variable/value.

Scalar::Construct can be helpful in generating appropriate REFs, especially to create constants. There are Perl core bugs to beware of around compile-time constants; see "BUGS".

Lexical::Var->unimport(NAME [=> REF], ...)

Sets up negative lexical variable declarations, in the lexical environment that is currently compiling. Each NAME must be a variable name (e.g., "$foo") including sigil. If the name is given on its own, it is lexically dissociated from any value. Within the resulting scope, the variable name will not be recognised. If a REF (which must be a reference to a value of the appropriate type) is specified with a name, the name will be dissociated if and only if it is currently associated with that value.