Under older perls this module provides a drop in compatible api to the
Hash::Util::FieldHash manpage using the perltie manpage. When the
Hash::Util::FieldHash manpage is available it will use that instead.

This way code requiring field hashes can benefit from fast, robust field
hashes on Perl 5.10 and newer, but still run on older perls that don't ship
with that module.

See the Hash::Util::FieldHash manpage for all the details of the API.

HTML::RewriteAttributes is designed for simple yet powerful HTML attribute
rewriting.

You simply specify a callback to run for each attribute and we do the rest for
you.

This module is designed to be subclassable to make handling special cases
eaiser. See the source for methods you can override.

Author:
-------
Shawn M Moore,

This is a simple standalone HTTP server. By default, it doesn't thread or fork.
It does, however, act as a simple frontend which can be used to build a
standalone web-based application or turn a CGI into one.

It is possible to use Net::Server classes to create forking, pre-forking, and
other types of more complicated servers; see "net_server".

Author:
-------
Jesse Vincent,

Finding the home country of a client using only the IP address can be
difficult. Looking up the domain name associated with that address can provide
some help, but many IP addresses are not reverse mapped to any useful domain, and
the most common domain (.com) offers no help when looking for country.

This module comes bundled with a database of countries where various IP
addresses have been assigned. Although the country of assignment will probably
be the country associated with a large ISP rather than the client herself, this
is probably good enough for most log analysis applications, and under test has
proved to be as accurate as reverse-DNS and WHOIS lookup.

JSON-RPC is a stateless and light-weight remote procedure call (RPC)
protocol for inter-networking applications over HTTP. It uses JSON as the
data format for of all facets of a remote procedure call, including all
application data carried in parameters.

The old modules - JSONRPC::Transport::HTTP and Apache::JSONRPC are deprecated.
Please try to use JSON::RPC::Server and JSON::RPC::Client which support both
JSON-RPC protocol version 1.1 and 1.0.

Stemming reduces related words to a common root form -- for instance,
"horse", "horses", and "horsing" all become "hors". Most commonly, stemming
is deployed as part of a search application, allowing searches for a given
term to match documents which contain other forms of that term.

This module allows you to map from US two-letter codes to statees and vice
versa.

Author:
-------
T. M. Brannon,

This simple locking scheme is not based on any file locking system calls
such as 'flock()' or 'lockf()' but rather relies on basic file system
primitives and properties, such as the atomicity of the 'write()' system
call. It is not meant to be exempt from all race conditions, especially
over NFS. The algorithm used is described below in the *ALGORITHM* section.

It is possible to customize the locking operations to attempt locking once
every 5 seconds for 30 times, or delete stale locks (files that are deemed
too ancient) before attempting the locking.

This module is a generalization of the functionality provided by
Apache::StatINC and Apache::Reload. It's designed to make it easy to do simple
iterative development when working in a persistent environment.

It does not require mod_perl.

Author:
-------
Jesse Vincent ,
Autrijus Tang

This module provides some useful test functions for Mouse based classes.
It is an experimental first release, so comments and suggestions are very
welcome.

Net::Whois::Raw queries WHOIS servers about domains. The module supports
recursive WHOIS queries. Also queries via HTTP is supported for some TLDs.

Setting the variables $OMIT_MSG and $CHECK_FAIL will match the results against
a set of known patterns. The first flag will try to omit the copyright
message/disclaimer, the second will attempt to determine if the search failed
and return undef in such a case.

IMPORTANT: these checks merely use pattern matching; they will work on several
servers but certainly not on all of them.

Author:
-------
Ariel Brosh schop@cpan.org
Gabor Szabo gabor@perl.org.il
Corris Randall corris@cpan.org
Walery Studennikov despair@cpan.org

A big part of good API design is that we should be able to be flexible in the
ways that we take parameters.

Params::Coerce attempts to encourage this, by making it easier to take a
variety of different arguments, while adding negligable additional complexity
to your code.

Author:
-------
Adam Kennedy

'Params::Util' provides a basic set of importable functions that makes
checking parameters a hell of a lot easier

While they can be (and are) used in other contexts, the main point behind
this module is that the functions *both* Do What You Mean, and Do The Right
Thing, so they are most useful when you are getting params passed into your
code from someone and/or somewhere else and you can't really trust the
quality.

Thus, 'Params::Util' is of most use at the edges of your API, where params
and data are coming in from outside your code.

The functions provided by 'Params::Util' check in the most strictly correct
manner known, are documented as thoroughly as possible so their exact
behaviour is clear, and heavily tested so make sure they are not fooled by
weird data and Really Bad Things.

To use, simply load the module providing the functions you want to use as
arguments (as shown in the SYNOPSIS).

To aid in maintainability, 'Params::Util' will *never* export by default.

You must explicitly name the functions you want to export, or use the
':ALL' param to just have it export everything (although this is not
recommended if you have any _FOO functions yourself with which future
additions to 'Params::Util' may clash)

This is a lightweight module which provides 'Junction' operators, the most
commonly used being 'any' and 'all'.

Inspired by the Perl6 design docs, the
http://dev.perl.org/perl6/doc/design/exe/E06.html manpage.

Provides a limited subset of the functionality of the
Quantum::Superpositions manpage, see the /"SEE ALSO" manpage for comment.

Notice in the the /SYNOPSIS manpage above, that if you want to match
against a regular expression, you must use '==' or '!='. *Not* '=~' or
'!~'. You must also use a regex object, such as 'qr/\d/', not a plain regex
such as '/\d/'.

When using the Pod::Coverage manpage in combination with the Moose manpage,
it will report any method imported from a Role. This is especially bad when
used in combination with the Test::Pod::Coverage manpage, since it takes
away its ease of use.

To use this module in combination with the Test::Pod::Coverage manpage, use
something like this:

use Test::Pod::Coverage;
all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::Moose'});

POE is a framework for cooperative, event driven multitasking and networking in
Perl. Other languages have similar frameworks. Python has Twisted. TCL has "the
event loop".

POE originally was developed as the core of a persistent object server and
runtime environment. It has since evolved into something much more generic and
widely useful.

POE provides a unified interface for several other event loops, including
select(), IO::Poll, Glib, Gtk, Tk, Wx, Gtk2, and so on. Check the CPAN for the
full list of POE::Loop modules.

POE is designed in layers, each building atop the lower level ones. Programs
are free to use POE at any level of abstraction, and different levels can be
mixed and matched seamlessly within a single program.

POE's bundled abstraction layers are the tip of a growing iceberg. Sprocket,
POE::Stage, and other CPAN distributions build upon this work. You're
encouraged to look around.

No matter how high you go, though, it all boils down to calls to POE::Kernel.
So your down-to-earth code can easily cooperate with stratospheric systems.

POE::Test::Loops contains one function, generate(), which will generate all
the loop tests for one or more POE::Loop subclasses.

The "SYNOPSIS" example is a version of poe-gen-tests, which is a
stand-alone utility to generate the actual tests. poe-gen-tests also
documents the POE::Test::Loops system in more detail.

'Test::LeakTrace' provides several functions that trace memory leaks. This
module scans arenas, the memory allocation system, so it can detect any
leaked SVs in given blocks.

*Leaked SVs* are SVs which are not released after the end of the scope they
have been created. These SVs include global variables and internal caches.
For example, if you call a method in a tracing block, perl might prepare a
cache for the method. Thus, to trace true leaks, 'no_leaks_ok()' and
'leaks_cmp_ok()' executes a block more than once.

This module provides some drop-in replacements for the string comparison
functions of Test::More, but which are more suitable when you test against long
strings. If you've ever had to search for text in a multi-line string like an
HTML document, or find specific items in binary data, this is the module for
you.

The perl-Test-NoWarnings package

If you have written a test module based on Test::Builder then Test::Tester
allows you to test it with the minimum of effort.

According to the *Test::More* documentation, it is recommended to run
'use_ok()' inside a 'BEGIN' block, so functions are exported at
compile-time and prototypes are properly honored.

That is, instead of writing this:

use_ok( 'Some::Module' );
use_ok( 'Other::Module' );

One should write this:

BEGIN { use_ok( 'Some::Module' ); }
BEGIN { use_ok( 'Other::Module' ); }

However, people often either forget to add 'BEGIN', or mistakenly group
'use_ok' with other tests in a single 'BEGIN' block, which can create
subtle differences in execution order.

With this module, simply change all 'use_ok' in test scripts to 'use ok',
and they will be executed at 'BEGIN' time. The explicit space after 'use'
makes it clear that this is a single compile-time action.

Text::CSV provides facilities for the composition and decomposition of
comma-separated values using the Text::CSV_XS manpage or its pure Perl
version.

An instance of the Text::CSV class can combine fields into a CSV string and
parse a CSV string into fields.

The module accepts either strings or files as input and can utilize any
user-specified characters as delimiters, separators, and escapes so it is
perhaps better called ASV (anything separated values) rather than just CSV.

This module provides bare bones 'try'/'catch'/'finally' statements that are
designed to minimize common mistakes with eval blocks, and NOTHING else.

This is unlike the TryCatch manpage which provides a nice syntax and avoids
adding another call stack layer, and supports calling 'return' from the try
block to return from the parent subroutine. These extra features come at a
cost of a few dependencies, namely the Devel::Declare manpage and the
Scope::Upper manpage which are occasionally problematic, and the additional
catch filtering uses the Moose manpage type constraints which may not be
desirable either.

The main focus of this module is to provide simple and reliable error
handling for those having a hard time installing the TryCatch manpage, but
who still want to write correct 'eval' blocks without 5 lines of
boilerplate each time.

This module converts strings from and to 2-byte Unicode UCS2 format. All
mappings happen via 2 byte UTF16 encodings, not via 1 byte UTF8 encoding.
To transform these use Unicode::String.

For historical reasons this module coexists with Unicode::Map8. Please use
Unicode::Map8 unless you need to care for two byte character sets, e.g.
chinese GB2312. Anyway, if you stick to the basic functionality (see
documentation) you can use both modules equivalently.

Practically this module will disappear from earth sooner or later as
Unicode mapping support needs somehow to get into perl's core. If you like
to work on this field please don't hesitate contacting Gisle Aas!

This module can't deal directly with utf8. Use Unicode::String to convert
utf8 to utf16 and vice versa.

Character mapping is according to the data of binary mapfiles in
Unicode::Map hierarchy. Binary mapfiles can also be created with this
module, enabling you to install own specific character sets. Refer to
mkmapfile or file REGISTRY in the Unicode::Map hierarchy.