The Params::Validate module allows you to validate method or function
call parameters to an arbitrary level of specificity. At the simplest
level, it is capable of validating the required parameters were given
and that no unspecified additional parameters were passed in.

It is also capable of determining that a parameter is of a specific
type, that it is an object of a certain class hierarchy, that it
possesses certain methods, or applying validation callbacks to
arguments.

The Comprehensive Perl Archive Network (CPAN) is a very useful collection
of Perl code. It has several indices of the files that it hosts, including
a file named "02packages.details.txt.gz" in the "modules" directory. This
file contains lots of useful information and this module provides a simple
interface to the data contained within.

In a future release the Parse::CPAN::Packages::Package manpage and the
Parse::CPAN::Packages::Distribution manpage might have more information.

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.

Provides a simple, quick means of serializing perl memory structures
(including object data!) into a format that PHP can deserialize() and
access, and vice versa.

NOTE: Converts PHP arrays into Perl Arrays when the PHP array used
exclusively numeric indexes, and into Perl Hashes then the PHP array did
not.

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.

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.

This module is a subclass of L which provides additional
POD markup for generating F files.

Why should one bother with this? One can simply use

pod2text Module.pm > README

A problem with doing that is that the default L converter will
add text to links, so that "LZ<>" is translated to "the Module
manpage".

Another problem is that the F includes the entirety of the module
documentation! Most people browsing the F file do not need all of
this information.

Likewise, including installation and requirement information in the module
documentation is not necessary either, since the module is already
installed.

This module allows authors to mark portions of the POD to be included only
in, or to be excluded from the F file. It also allows you to
include portions of another file (such as a separate F).

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

This package shares with PPI the property of being round-trip safe. That
is,

my $expr = 's/ ( \d+ ) ( \D+ ) /$2$1/smxg';
my $re = PPIx::Regexp->new( $expr );
print $re->content() eq $expr ? "yes\n" : "no\n"

should print 'yes' for any valid regular expression.

Navigation is similar to that provided by PPI. That is to say, things like
'children', 'find_first', 'snext_sibling' and so on all work pretty much
the same way as in PPI.

The class hierarchy is also similar to PPI. Except for some utility classes
(the dumper, the lexer, and the tokenizer) all classes are descended from
PPIx::Regexp::Element, which provides basic navigation. Tokens are
descended from PPIx::Regexp::Token, which provides content. All containers
are descended from PPIx::Regexp::Node, which provides for children, and all
structure elements are descended from PPIx::Regexp::Structure, which
provides beginning and ending delimiters, and a type.

There are two features of PPI that this package does not provide -
mutability and operator overloading. There are no plans for serious
mutability, though something like PPI's 'prune' functionality might be
considered. Similarly there are no plans for operator overloading, which
appears to the author to represent a performance hit for little tangible
gain.

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.

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.

the Rose::Object manpage is a generic object base class. It provides very
little functionality, but a healthy dose of convention.

Programming SDL with Perl.

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.

Lingua::Stem::Snowball::No is a perl port of the norwegian
stemmer at http://snowball.tartarus.org.

Lingua::Stem::Snowball::Se is a perl port of the swedish
stemmer at http://snowball.sourceforge.net.

Software::License
packages that provide templated software licenses

Authors:
--------
Ricardo SIGNES

This module exports two functions, nsort and ncmp; they are used in
implementing my idea of a "natural sorting" algorithm. Under natural
sorting, numeric substrings are compared numerically, and other word-
characters are compared lexically.

The Spreadsheet::ParseExcel module can be used to read information from
Excel 95-2003 binary files.

The module cannot read files in the Excel 2007 Open XML XLSX format. See
the the Spreadsheet::XLSX manpage module instead.