Arch is a really nifty revision control system. It's "whole-tree changeset
based" which means, roughly, that it can handle (with atomic commits) file
and directory adds, deletes, and renames cleanly, and that it does branching
simply and easily. Arch is also "distributed" which means, for example that
you can make arch branches of your own from remote projects, even if you do
not have write access to the revision control archives for those projects.
Extract links from JSON via a schema
search nested hashref/arrayref structures using JSONPath
Log::Any allows CPAN modules to safely and efficiently log messages,
while letting the application choose (or decline to choose) a logging
mechanism such as Log::Dispatch or Log::Log4perl.
JSON::RPC - Perl implementation of JSON-RPC 1.1 protocol.
Validate JSON against a schema.
Lexical::Import allows functions and other items, from a separate module, to be
imported into the lexical namespace (as implemented by Lexical::Var), when the
exporting module exports non-lexically to a package in the traditional manner.
This is a translation layer, to help code written in the new way to use modules
written in the old way.
A lexically-imported item 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. Within its scope, any use of the single-part name of the
item (e.g., "$foo") refers directly to that item, regardless of what is in any
package. Explicitly package-qualified names (e.g., "$main::foo") still refer to
the package. There is no conflict between a lexical name definition and the same
name in any package.
This mechanism only works on Perl 5.11.2 and later. Prior to that, it is
impossible for lexical subroutine imports to work for bareword subroutine calls.
(See "BUGS" in Lexical::Var for details.) Other kinds of lexical importing are
possible on earlier Perls, but because this is such a critical kind of usage in
most code, this module will ensure that it works, for convenience. If the
limited lexical importing is desired on earlier Perls, use Lexical::Var
directly.
Lexical::Persistence does a few things, all related. Note that all the
behaviors listed here are the defaults. Subclasses can override nearly
every aspect of Lexical::Persistence's behavior.
Lexical::Persistence lets your code access persistent data through lexical
variables. This example prints "some value" because the value of $x
persists in the $lp object between setter() and getter().
use Lexical::Persistence;
my $lp = Lexical::Persistence->new();
$lp->call(\&setter);
$lp->call(\&getter);
sub setter { my $x = "some value" }
sub getter { print my $x, "\n" }
Perl module to prevent leakage of lexical hints
Lexical::SealRequireHints works around two historical bugs in Perl's handling of
the %^H (lexical hints) variable. One bug causes lexical state in one file to
leak into another that is required/used from it. This bug, [perl #68590], was
present from Perl 5.6 up to Perl 5.10, fixed in Perl 5.11.0. The second bug
causes lexical state (normally a blank %^H once the first bug is fixed) to leak
outwards from utf8.pm, if it is automatically loaded during Unicode regular
expression matching, into whatever source is compiling at the time of the regexp
match. This bug, [perl #73174], was present from Perl 5.8.7 up to Perl 5.11.5,
fixed in Perl 5.12.0.
Both of these bugs seriously damage the usability of any module relying on %^H
for lexical scoping, on the affected Perl versions. It is in practice essential
to work around these bugs when using such modules. On versions of Perl that
require such a workaround, this module globally changes the behaviour of
require, including use and the implicit require performed in Unicode regular
expression matching, so that it no longer exhibits these bugs.
Perl module for static variables without namespace pollution
Lexical::Var and Lexical::Sub implement lexical scoping of static variables and
subroutines. Although it can be used directly, it is mainly intended to be
infrastructure for modules that export particular objects.
Lexical::Var 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.
Lexical::Sub is implemented through the mechanism of Lexical::Var. Its distinct
name and declaration syntax exist to make lexical subroutine declarations
clearer.