This module allows you to manage a set of deprecations for one or
more modules.

Manipulating stashes (Perl's symbol tables) is occasionally necessary, but
incredibly messy, and easy to get wrong. This module hides all of that
behind a simple API.

NOTE: Most methods in this class require a variable specification that
includes a sigil. If this sigil is absent, it is assumed to represent the
IO slot.

Due to limitations in the typeglob API available to perl code, and to
typeglob manipulation in perl being quite slow, this module provides two
implementations - one in pure perl, and one using XS. The XS implementation
is to be preferred for most usages; the pure perl one is provided for cases
where XS modules are not a possibility. The current implementation in use
can be set by setting '$ENV{PACKAGE_STASH_IMPLEMENTATION}' or
'$Package::Stash::IMPLEMENTATION' before loading Package::Stash (with the
environment variable taking precedence), otherwise, it will use the XS
implementation if possible, falling back to the pure perl one.

Inspired by Perl6::Signature but streamlined to just support the subset
deemed useful for TryCatch and MooseX::Method::Signatures.

Subroutines are an excellent unit of reuse, in some ways they are even
superior to objects (simpler, map better to HTTP/network programming due to
being stateless, etc). Sub::Spec aims to make your subs much more useful,
reusable, powerful.

Test::Class provides a simple way of creating classes and objects to test
your code in an xUnit style.
Built using Test::Builder, it was designed to work with other
Test::Builder based modules (Test::More, Test::Differences,
Test::Exception, etc.).
*Note:* This module will make more sense, if you are already familiar with
the "standard" mechanisms for testing perl code. Those unfamiliar with
Test::Harness, Test::Simple, Test::More and friends should go take a look
at them now. Test::Tutorial is a good starting point.

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

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

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.

At some point or another, most programmers find they need to compare
floating-point numbers for equality. The typical idiom is to test if the
absolute value of the difference of the numbers is within a desired tolerance,
usually called epsilon. This module provides such a function for use with
Test::Harness. Usage is similar to other test functions described in
Test::More.

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

Test::SharedFork is utility module for Test::Builder. This module makes
forking test!

Check POD files for spelling mistakes, using Pod::Spell and spell to do
the heavy lifting.

Primarily (but not exclusively) for use in test scripts: A block eval on
steroids, configurable and extensible, but by default trapping (Perl)
STDOUT, STDERR, warnings, exceptions, would-be exit codes, and return
values from boxed blocks of test code.
The values collected by the latest trap can then be queried or tested
through a special trap object.

This module lets you easily test the validity of YAML.

While the perldoc/tie manpage allows tying to an arbitrary object, the
class in question must support this in it's implementation of 'TIEHASH',
'TIEARRAY' or whatever.

This class provides a very tie constructor that simply returns the object
it was given as it's first argument.

This way side effects of calling '$object->TIEHASH' are avoided.

This is used in the Data::Visitor manpage in order to tie a variable to an
already existing object. This is also useful for cloning, when you want to
clone the internal state object instead of going through the tie interface
for that variable.

This module aims to provide a nicer syntax and method to catch errors in
Perl, similar to what is found in other languages (such as Java, Python or
C++). The standard method of using "eval {}; if ($@) {}" is often prone to
subtle bugs, primarily that its far too easy to stomp on the error in
error handlers. And also eval/if isn't the nicest idiom.

This module implements the *stringprep* framework for preparing Unicode
text strings in order to increase the likelihood that string input and
string comparison work in ways that make sense for typical users
throughout the world. The *stringprep* protocol is useful for protocol
identifier values, company and personal names, internationalized domain
names, and other text strings.
The *stringprep* framework does not specify how protocols should prepare
text strings. Protocols must create profiles of stringprep in order to
fully specify the processing options.

The module provides means of pasting large texts into the
http://pastebin.com pastebin site.

This module deals with decoding of strings with XML character entities.

XML::SematicDiff provides a way to compare the contents and structure of two
XML documents. By default, it returns a list of hashrefs where each hashref
describes a single difference between the two docs.

Kirill Siminov's libyaml is arguably the best YAML implementation. The C
library is written precisely to the YAML 1.1 specification. It was originally
bound to Python and was later bound to Ruby.

This module is a Perl XS binding to libyaml which offers Perl the best YAML
support to date.

This module exports the functions Dump and Load. These functions are intended
to work exactly like YAML.pm's corresponding functions.

*YAML::Tiny* is a perl class for reading and writing YAML-style files,
written with as little code as possible, reducing load time and memory
overhead.

Most of the time it is accepted that Perl applications use a lot of memory
and modules. The *::Tiny* family of modules is specifically intended to
provide an ultralight and zero-dependency alternative to many more-thorough
standard modules.

This module is primarily for reading human-written files (like simple
config files) and generating very simple human-readable files. Note that I
said *human-readable* and not *geek-readable*. The sort of files that your
average manager or secretary should be able to look at and make sense of.

the YAML::Tiny manpage does not generate comments, it won't necesarily
preserve the order of your hashes, and it will normalise if reading in and
writing out again.

It only supports a very basic subset of the full YAML specification.

Usage is targetted at files like Perl's META.yml, for which a small and
easily-embeddable module is extremely attractive.

Features will only be added if they are human readable, and can be written
in a few lines of code. Please don't be offended if your request is
refused. Someone has to draw the line, and for YAML::Tiny that someone is
me.

If you need something with more power move up to the YAML manpage (4
megabytes of memory overhead) or the YAML::Syck manpage (275k, but requires
libsyck and a C compiler).

To restate, the YAML::Tiny manpage does *not* preserve your comments,
whitespace, or the order of your YAML data. But it should round-trip from
Perl structure to file and back again just fine.