RecDescent incrementally generates top-down recursive-descent text
parsers from simple yacc-like grammar specifications.

Parse::Yapp (Yet Another Perl Parser compiler) is a collection of
modules that let you generate and use yacc like thread safe (reentrant)
parsers with perl object oriented interface.

The perlDL project aims to turn perl into an efficient numerical
language for scientific computing. The PDL module gives standard perl
the ability to compactly store and speedily manipulate the large
N-dimensional data sets.

Perl::Critic is an extensible framework for creating and applying coding
standards to Perl source code. Essentially, it is a static source code
analysis engine. Perl::Critic is distributed with a number of
Perl::Critic::Policy modules that attempt to enforce various coding
guidelines. Most Policy modules are based on Damian Conway's book Perl Best
Practices. However, Perl::Critic is not limited to PBP and will even
support Policies that contradict Conway. You can enable, disable, and
customize those Polices through the Perl::Critic interface. You can also
create new Policy modules that suit your own tastes.

For a command-line interface to Perl::Critic, see the documentation for
perlcritic. If you want to integrate Perl::Critic with your build
process, Test::Perl::Critic provides an interface that is suitable for
test programs. Also, Test::Perl::Critic::Progressive is useful for
gradually applying coding standards to legacy code. For the ultimate
convenience (at the expense of some flexibility) see the criticism
pragma.

PlRPC (Perl RPC) is a package for implementing servers and clients that
are entirely written in Perl. The name is borrowed from Sun's RPC
(Remote Procedure Call), but it could as well be RMI like Java's Remote
Method Interface, because PlRPC gives you the complete power of Perl's
OO framework in a very simple manner.

Developers hate writing documentation. They'd hate it even more if their
computer tattled on them, but maybe they'll be even more thankful in the
long run. Even if not, perlmodstyle tells you to, so you must obey.

This module provides a mechanism for determining if the pod for a given
module is comprehensive.

It expects to find either a =head(n>1) or an =item block documenting a
subroutine.

Documentation projects builder in HTML, PS and PDF formats.

This module implements a parser to convert Pod documents into a simple
object model form known hereafter as the Pod Object Model. The object model
is generated as a hierarchical tree of nodes, each of which represents a
different element of the original document. The tree can be walked manually
and the nodes examined, printed or otherwise manipulated. In addition,
Pod::POM supports and provides view objects which can automatically
traverse the tree, or section thereof, and generate an output
representation in one form or another.

Pod::Spell is a Pod formatter whose output is good for spellchecking.
Pod::Spell rather like Pod::Text, except that it doesn't put much effort
into actual formatting, and it suppresses things that look like Perl
symbols or Perl jargon (so that your spellchecking program won't complain
about mystery words like "$thing" or "Foo::Bar" or "hashref").

This class provides no new public methods. All methods of interest are
inherited from Pod::Parser (which see). The especially interesting ones
are `parse_from_filehandle' (which without arguments takes from STDIN
and sends to STDOUT) and `parse_from_file'. But you can probably just
make do with the examples in the synopsis though.

This class works by filtering out words that look like Perl or any form
of computerese (like "`$thing'" or "`N>7'" or "`@{$foo}{'bar','baz'}'",
anything in C<...> or F<...> codes, anything in verbatim paragraphs
(codeblocks), and anything in the stopword list. The default stopword
list for a document starts out from the stopword list defined by
Pod::Wordlist, and can be supplemented (on a per-document basis) by
having `"=for stopwords"' / `"=for :stopwords"' region(s) in a document.

The purpose of PPI is not to parse Perl *Code*, but to parse Perl
*Documents*. By treating the problem this way, we are able to parse a
single file containing Perl source code "isolated" from any other
resources, such as libraries upon which the code may depend, and without
needing to run an instance of perl alongside or inside the parser.

The purpose of the PPIx-Regexp package is to parse regular expressions in a
manner similar to the way the PPI package parses Perl. This class forms the
root of the parse tree, playing a role similar to PPI::Document.

The PPIx::Regexp object is instantiated using either new() or
new_from_cache(). Either way, you must pass it a regular expression,
either as a string or as one of the three relevant PPI objects:
PPI::Token::StringLike::Regexp, PPI::Token::Regexp::Match, or
PPI::Token::Regexp::Substitute. In the case of new_from_cache(), only
one PPIx::Regexp object will be generated from a given PPI object;
subsequent calls with the same PPI object will return the same
PPIx::Regexp object.

This is a collection of functions for dealing with PPI objects, many of
which originated in Perl::Critic. They are organized into modules by the
kind of PPI class they relate to, by replacing the "PPI" at the front of
the module name with "PPIx::Utilities", e.g. functionality related to
PPI::Nodes is in PPIx::Utilities::Node.

The Quantum::Superpositions module provides a new scalar data
structure: the superposition. In a metaphor drawn from quantum
mechanics, superpositions store a collection of values by overlaying
them in parallel superimposed states within a single scalar variable.

Readonly.pm provides a facility for creating non-modifiable scalars,
arrays, and hashes.

This is a companion module to Readonly.pm. You do not use
Readonly::XS directly. Instead, once it is installed, Readonly.pm
will detect this and will use it for creating read-only scalars. This
results in a significant speed improvement. This does not speed up
read-only arrays or hashes.

Set::Crontab parses crontab-style lists of integers and defines some
utility functions to make it easier to deal with them.

This module implements a Set of objects, that is, a collection of
objects without duplications. It is similar to a Smalltalk IdentitySet.

This module implements a Set of scalars.

SGMLSpm is a Perl script that reads ESIS output (from parsers like SP)
and offers an event-based interface to the parser. As long as the
parser can parse XML this also works for XML.

String::Format lets you define arbitrary printf-like format sequences to be
expanded. This module would be most useful in configuration files and
reporting tools, where the results of a query need to be formatted in a
particular way. It was inspired by mutt's index_format and related
directives
(see ).

Sub::Exporter provides a sophisticated alternative to Exporter.pm. It allows
for renaming, currying/sub-generation, and other cool stuff. Read its own
documentation.

The biggest benefit of Sub::Exporter over existing exporters
(including the ubiquitous Exporter.pm) is its ability to build new coderefs
for export, rather than to simply export code identical to that found
in the exporting package.

Author: Ricardo Signes,

Sub::Identify allows you to retrieve the real name of code references.
For this, it uses perl's introspection mechanism, provided by the
B module.

This module makes it easy to install subroutines into packages without the
unslightly mess of no strict or typeglobs lying about where just anyone
can see them.

Author: Ricardo Signes,

Like Tcl's uplevel() function, but not quite so dangerous. The idea is
just to fool caller(). All the really naughty bits of Tcl's uplevel()
are avoided.

When subclassing a class, you occasionally want to dispatch control to the
superclass -- at least conditionally and temporarily. The Perl syntax for
calling your superclass is ugly and unwieldy: