This is an interactive shell for Perl, commonly known as a REPL - Read,
Evaluate, Print, Loop. The shell provides for rapid development or testing of
code without the need to create a temporary source code file.

Through a plugin system, many features are available on demand. You can also
tailor the environment through the use of profiles and run control files, for
example to pre-load certain Perl modules when working on a particular project.

String eval is often used for dynamic code generation. For instance,
'Moose' uses it heavily, to generate inlined versions of accessors and
constructors, which speeds code up at runtime by a significant amount.
String eval is not without its issues however - it's difficult to control
the scope it's used in (which determines which variables are in scope
inside the eval), and it can be quite slow, especially if doing a large
number of evals.

This module attempts to solve both of those problems. It provides an
'eval_closure' function, which evals a string in a clean environment, other
than a fixed list of specified variables. It also caches the result of the
eval, so that doing repeated evals of the same source, even with a
different environment, will be much faster (but note that the description
is part of the string to be evaled, so it must also be the same (or
non-existent) if caching is to work properly).

Perl extension for recursively copying files and directories.

File::Next is an iterator-based module for finding files. It's
lightweight, has no dependencies, runs under taint mode, and puts your
program more directly in control of file selection.

This module reads a file backwards line by line. It is simple to use, memory
efficient and fast. It supports both an object and a tied handle interface.

It is intended for processing log and other similar text files which typically
have their newest entries appended to them. By default files are assumed to be
plain text and have a line ending appropriate to the OS. But you can set the
input record separator string on a per file basis.

This module simply interpolates option file hints in @ARGV by the contents of
the pointed files. This enables option reading from files instead of or
additional to the usual reading from the command line.

Alternatively, you can process any array instead of @ARGV which is used by
default and mentioned mostly in this manual.

The interpolated @ARGV could be subsequently processed by the usual option
handling, e.g. by a Getopt::xxx module. Getopt::ArgvFile does not perform any
option handling itself, it only prepares the array @ARGV.

Similar to "List::MoreUtils", "Hash::MoreUtils" contains trivial but
commonly-used functionality for hashes.

HTTP::Lite is a stand-alone lightweight HTTP/1.1 implementation
for perl.

It is not intended as a replacement for the fully-features LWP module. Instead,
it is intended for use in situations where it is desirable to install the
minimal number of modules to achieve HTTP support, or where LWP is not a good
candidate due to CPU overhead, such as slower processors.

HTTP::Lite is also significantly faster than LWP.

HTTP::Lite is ideal for CGI (or mod_perl) programs or for bundling for
redistribution with larger packages where only HTTP GET and POST functionality
are necessary.

IO::All combines all of the best Perl IO modules into a single nifty
object oriented interface to greatly simplify your everyday Perl IO
idioms. It exports a single function called "io", which returns a new
IO::All object. And that object can do it all!

produce tied (and other) separate but combined variables

Calling Perl's in-built "system()" function is easy, determining if it was
successful is *hard*. Let's face it, $? isn't the nicest variable in the
world to play with, and even if you *do* check it, producing a
well-formatted error string takes a lot of work.
"IPC::System::Simple" takes the hard work out of calling external
commands.

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 perists in
the $lp object between setter() and getter().

Are you sick of trying to remember whether a particular helper is defined
in "List::Util" or "List::MoreUtils"? I sure am. Now you don't have to
remember. This module will export all of the functions that either of
those two modules defines.

This module provides a quick, convenient way of bootstrapping a user-local Perl
module library located within the user's home directory. It also constructs and
prints out for the user the list of environment variables using the syntax
appropriate for the user's current shell (as specified by the SHELL environment
variable), suitable for directly adding to one's shell configuration file.

More generally, local::lib allows for the bootstrapping and usage of a
directory containing Perl modules outside of Perl's @INC. This makes it easier
to ship an application with an app-specific copy of a Perl module, or
collection of modules. Useful in cases like when an upstream maintainer hasn't
applied a patch to a module of theirs that you need for your application.

This module does the same thing as msgfmt from GNU gettext-tools, except this
is pure Perl.

'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'.

'Log::Any' has a very tiny footprint and no dependencies beyond Perl 5.6,
which makes it appropriate for even small CPAN modules to use. It defaults
to 'null' logging activity, so a module can safely log without worrying
about whether the application has chosen (or will ever choose) a logging
mechanism.

The application, in turn, may choose one or more logging mechanisms via
Log::Any::Adapter.

This provides a Log::Dispatch log output system that appends logged events
to an array reference. This is probably only useful for testing the
logging of your code.

MIME::Charset provides informations about character sets used for MIME messages
on Internet.

*Module::Install* is a package for writing installers for CPAN (or
CPAN-like) distributions that are clean, simple, minimalist, act in a
strictly correct manner with the ExtUtils::MakeMaker manpage, and will run
on any Perl installation version 5.005 or newer.

The intent is to make it as easy as possible for CPAN authors (and
especially for first-time CPAN authors) to have installers that follow all
the best practices for distribution installation, but involve as much DWIM
(Do What I Mean) as possible when writing them.

Adds contextual tests that the harness can ignore.

This module scans potential modules used by perl programs, and returns a
hash reference; its keys are the module names as appears in '%INC' (e.g.
'Test/More.pm'); the values are hash references with this structure:

{
file => '/usr/local/lib/perl5/5.8.0/Test/More.pm',
key => 'Test/More.pm',
type => 'module', # or 'autoload', 'data', 'shared'
used_by => [ 'Test/Simple.pm', ... ],
uses => [ 'Test/Other.pm', ... ],
}

One function, 'scan_deps', is exported by default. Other functions such as
('scan_line', 'scan_chunk', 'add_deps', 'path_to_inc_name') are exported
upon request.

Users of *App::Packer* may also use this module as the dependency-checking
frontend, by tweaking their _p2e.pl_ like below:

use Module::ScanDeps;
...
my $packer = App::Packer->new( frontend => 'Module::ScanDeps' );
...

Please see the App::Packer::Frontend manpage for detailed explanation on
the structure returned by 'get_files'.

Moose is an extension of the Perl 5 object system.

The main goal of Moose is to make Perl 5 Object Oriented programming
easier, more consistent, and less tedious. With Moose you can think more
about what you want to do and less about the mechanics of OOP.

Additionally, Moose is built on top of the Class::MOP manpage, which is a
metaclass system for Perl 5. This means that Moose not only makes building
normal Perl 5 objects better, but it provides the power of metaclass
programming as well.

The MooseX::Aliases module will allow you to quickly alias methods in Moose. It
provides an alias parameter for has() to generate aliased accessors as well as
the standard ones. Attributes can also be initialized in the constructor via
their aliased names.

This module marries App::Cmd with MooseX::Getopt.

Use it like App::Cmd advises (especially see App::Cmd::Tutorial), swapping
App::Cmd::Command for MooseX::App::Cmd::Command.

Then you can write your moose commands as moose classes, with
MooseX::Getopt defining the options for you instead of "opt_spec"
returning a Getopt::Long::Descriptive spec.