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.

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

Authors:
--------
Damian Conway

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.

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.

Authors:
--------
Eric Roode,

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.

SOAP::Lite is a collection of Perl modules which provides a simple and
lightweight interface to the Simple Object Access Protocol (SOAP) both on
client and server side.

Authors:
--------
Paul Kulchenko
Martin Kutter
Randy J. Ray
Byrne Reese

This module contains some functions which are useful for quoting strings
which are going to pass through the shell or a shell-like object.

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.

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.

The Switch.pm module implements a generalized case mechanism that covers
most (but not all) of the numerous possible combinations of switch and
case values described above.The module augments the standard Perl syntax
with two new control statements: 'switch' and 'case'. The 'switch'
statement takes a single scalar argument of any type, specified in
parentheses. 'switch' stores this value as the current switch value in a
(localized) control variable. The value is followed by a block which may
contain one or more Perl statements (including the 'case' statement
described below). The block is unconditionally executed once the switch
value has been cached. A 'case' statement takes a single scalar argument
(in mandatory parentheses if it's a variable; otherwise the parens are
optional) and selects the appropriate type of matching between that
argument and the current switch value. The type of matching used is
determined by the respective types of the switch value and the 'case'
argument, as specified in Table 1. If the match is successful, the
mandatory block associated with the 'case' statement is executed.

Author:
-------
Damian Conway

Term::ProgressBar provides a simple progress bar on the terminal, to let the user know that something is happening, roughly how much stuff has been done, and maybe an estimate at how long remains.

A typical use sets up the progress bar with a number of items to do, and then calls update to update the bar whenever an item is processed.

This module, ReadKey, provides ioctl control for terminals and Win32 consoles
so the input modes can be changed (thus allowing reads of a single character at
a time), and also provides non-blocking reads of stdin, as well as several
other terminal related features, including retrieval/modification of the screen
size, and retrieval/modification of the control characters.

If you don't know anything about automated testing in Perl then you should
probably read about Test::Simple and Test::More before preceding.
Test::Deep uses the Test::Builder framework.
Test::Deep gives you very flexible ways to check that the result you got
is the result you were expecting. At it's simplest it compares two
structures by going through each level, ensuring that the values match,
that arrays and hashes have the same elements and that references are
blessed into the correct class. It also handles circular data structures
without getting caught in an infinite loop.

Authors:
--------
Fergal Daly
Ricardo Signes (Maintainer)

Test strings and data structures and show differences if not ok.

This module provides a few convenience methods for testing exception
based code. It is built with Test::Builder and plays happily with
Test::More and friends.

Test::Fatal is an alternative to the popular Test::Exception. It does much
less, but should allow greater flexibility in testing exception-throwing
code with about the same amount of typing.
It exports one routine by default: "exception".

This is another framework for writing test scripts. It is loosely inspired
by Test::More, and has most of it's functionality, but it is not a drop-in
replacement.

Authors:
--------
Sullivan Beck

Test::Most exists to reduce boilerplate and to make your testing life easier.
We provide "one stop shopping" for most commonly used testing modules. In fact,
we often require the latest versions so that you get bug fixes through
Test::Most and don't have to keep upgrading these modules separately.

This module provides you with the most commonly used testing functions, along
with automatically turning on strict and warning and gives you a bit more
fine-grained control over your test suite.

Check POD files for errors or warnings in a test file, using 'Pod::Simple'
to do the heavy lifting.

Test::Requires checks to see if the module can be loaded.

If this fails rather than failing tests this skips all tests.

This module provides a few convenience methods for testing warning
based code.

The 'Text::BibTeX' module serves mainly as a high-level introduction to the
'Text::BibTeX' library, for both code and documentation purposes. The code
loads the two fundamental modules for processing BibTeX files
('Text::BibTeX::File' and 'Text::BibTeX::Entry'), and this documentation
gives a broad overview of the whole library that isn't available in the
documentation for the individual modules that comprise it.

In addition, the 'Text::BibTeX' module provides a number of miscellaneous
functions that are useful in processing BibTeX data (especially the kind
that comes from bibliographies as defined by BibTeX 0.99, rather than
generic database files). These functions don't generally fit in the
object-oriented class hierarchy centred around the 'Text::BibTeX::Entry'
class, mainly because they are specific to bibliographic data and operate
on generic strings (rather than being tied to a particular BibTeX entry).
These are also documented here, in the "MISCELLANEOUS FUNCTIONS" manpage.

Note that every module described here begins with the 'Text::BibTeX'
prefix. For brevity, I have dropped this prefix from most class and module
names in the rest of this manual page (and in most of the other manual
pages in the library).

Text::CSV_XS provides facilities for the composition and decomposition of
comma-separated values. An instance of the Text::CSV_XS class will combine
fields into a 'CSV' string and parse a 'CSV' string into fields.

The module accepts either strings or files as input and support the use of
user-specified characters for delimiters, separators, and escapes.

diff() provides a basic set of services akin to the GNU diff utility. It is not anywhere near as feature complete as GNU diff, but it is better integrated with Perl and available on all platforms. It is often faster than shelling out to a system's diff executable for small files, and generally slower on larger files.