Simply loading this module makes your constructors "strict". If your
constructor is called with an attribute init argument that your class does not
declare, then it calls "Carp::confess()". This is a great way to catch small
typos.

Often you want to create components that can be added to a class
arbitrarily. This module makes it easy for the end user to use these
components. Instead of requiring the user to create a named class with the
desired roles applied, or apply roles to the instance one-by-one, he can
just create a new class from yours with "with_traits", and then
instantiate that.

This module packages several Moose::Util::TypeConstraints with coercions,
designed to work with the DateTime suite of objects.

MooseX::Types::Path::Class creates common Moose types, coercions and option
specifications useful for dealing with Path::Class objects as Moose attributes.

Coercions (see Moose::Util::TypeConstraints) are made from both 'Str' and
'ArrayRef' to both Path::Class::Dir and Path::Class::File objects. If you have
MooseX::Getopt installed, the Getopt option type ("=s") will be added for both
Path::Class::Dir and Path::Class::File.

A structured type constraint is a standard container Moose type
constraint, such as an ArrayRef or HashRef, which has been enhanced to
allow you to explicitly name all the allowed type constraints inside the
structure.

This type library enables structured type constraints. It is built on top
of the MooseX::Types library system, so you should review the
documentation for that if you are not familiar with it.

Perl module for Mouse to organize your types into libraries.

This module implements the nameprep specification, which describes how to
prepare internationalized domain name (IDN) labels in order to increase the
likelihood that name input and name comparison work in ways that make sense for
typical users throughout the world. Nameprep is a profile of the stringprep
protocol and is used as part of a suite of on-the-wire protocols for
internationalizing the Domain Name System (DNS).

OAuth is "An open protocol to allow secure API authentication in a simple and
standard method from desktop and web applications."

In practical terms, OAuth is a mechanism for a Consumer to request protected
resources from a Service Provider on behalf of a user.

Please refer to the OAuth spec: http://oauth.net/documentation/spec

Net::OAuth provides:
* classes that encapsulate OAuth messages (requests and responses).
* message signing
* message serialization and parsing.
* 2-legged requests (aka. tokenless requests, aka. consumer requests),
see "CONSUMER REQUESTS"

Net::OAuth does not provide:
* Consumer or Service Provider encapsulation
* token/nonce/key storage/management

Net::Pcap is a Perl binding to the LBL pcap(3) library. The README for libpcap
describes itself as: "a system-independent interface for user-level packet
capture. libpcap provides a portable framework for low-level network
monitoring. Applications include network statistics collection, security
monitoring, network debugging, etc."

This module provides a perl interface to the Twitter APIs. See
for a full
description of the Twitter APIs.

"NetPacket" provides a base class for a cluster of modules related to
decoding and encoding of network protocols. Each "NetPacket" descendent
module knows how to encode and decode packets for the network protocol it
implements. Consult the documentation for the module in question for
protocol-specific implementation.
Note that there is no inheritance in the "NetPacket::" cluster of modules
other than each protocol module being a "NetPacket". This was seen to be
too restrictive as imposing inheritance relationships (for example between
the IP, UDP and TCP protocols) would make things like tunneling or other
unusual situations difficult.

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!