This module provides a very simple, very clean, very specific interface to multiple Email mailers. The goal of this software is to be small and simple, easy to use, and easy to extend.

Email::Simple is the first deliverable of the "Perl Email Project." The Email:: namespace was begun as a reaction against the increasing complexity and bugginess of Perl's existing email modules. Email::* modules are meant to be simple to use and to maintain, pared to the bone, fast, minimal in their external dependencies, and correct.

This module determines whether an email address is well-formed, and
optionally, whether a mail host exists for the domain or whether the top level
domain of the email address is valid.

This Perl module is an Encode::Encoding subclass that uses
Encode::Detect::Detector to determine the charset of the input data and then
decodes it using the encoder of the detected charset.

It is similar to Encode::Guess, but does not require the configuration of a set
of expected encodings. Like Encode::Guess, it only supports decoding--it cannot
encode.

Authors:
--------
John Gardiner Myers

Exception::Class allows you to declare exception hierarchies in your modules in
a "Java-esque" manner.

It features a simple interface allowing programmers to 'declare' exception
classes at compile time. It also has a base exception class,
Exception::Class::Base, that can be easily extended.

It is designed to make structured exception handling simpler and better by
encouraging people to use hierarchies of exceptions in their applications,
as opposed to a single catch-all exception class.

This module does not implement any try/catch syntax. Please see the
"OTHER EXCEPTION MODULES (try/catch syntax)" section for more information on
how to get this syntax.

You will also want to look at the documentation for Exception::Class::Base,
which is the default base class for all exception objects created
by this module.

Author: Dave Rolsky

This is an alternative to Exporter intended to provide a lightweight subset of
its functionality. It supports import(), @EXPORT and @EXPORT_OK and not a
whole lot else.

HTML-Element-Extended is a package of several enhanced HTML::Element
classes, most of which arose during the effort to implement an
HTML::Element based table class.

The modules are:
HTML::ElementTable
HTML::ElementSuper
HTML::ElementGlob
HTML::ElementRaw

The resulting functionality enables:
tables
element globs
element coordinates
content replacement
content wrapping
element cloning
raw HTML string adoption

"HTML::FromText" converts plain text to HTML. There are a handfull of options
that shape the conversion.

Mason is a tool for building, serving and managing large web sites. Its
features make it an ideal backend for high load sites serving dynamic
content, such as online newspapers or database driven e-commerce sites.

Authors:
--------
Jonathan Swartz
Dave Rolsky
Ken Williams
John Williams

If you wanna "scrub" or "sanitize" html input in a reliable and flexible
fashion, then this module is for you.

I wasn't satisfied with HTML::Sanitizer because it is based on
HTML::TreeBuilder, so I thought I'd write something similar that works
directly with HTML::Parser.

An implementation of http get that keeps a local cache of fetched pages to
avoid fetching the same data from the server if it hasn't been updated. The
cache is stored on disk and is thus persistent between invocations.

IPC::ShareLite provides a simple interface to shared memory, allowing data to be efficiently communicated between processes.

JSON (JavaScript Object Notation) is a simple data format. See to
http://www.json.org/ and RFC4627(http://www.ietf.org/rfc/rfc4627.txt).

This module converts Perl data structures to JSON and vice versa using either
JSON::XS or JSON::PP.

JSON::XS is the fastest and most proper JSON module on CPAN which must be
compiled and installed in your environment. JSON::PP is a pure-Perl module
which is bundled in this distribution and has a strong compatibility to
JSON::XS.

This module try to use JSON::XS by default and fail to it, use JSON::PP
instead. So its features completely depend on JSON::XS or JSON::PP.

Authors:
--------
Makamaka Hannyaharamitu,

There are two kinds of numbers in English -- cardinals (1, 2, 3...), and
ordinals (1st, 2nd, 3rd...). This library provides functions for giving the
ordinal form of a number, given its cardinal value.

Often human-readable information is available in more than one language. Which
should you use? This module provides a way for the user to specify possible
languages in order of preference, and then to pick the best language of those
available. Different 'dialects' given by the 'territory' part of the language
specifier (such as en, en_GB, and en_US) are also supported.

This module is a better way of putting 'hello there' trace messages in
your code. It lets you turn tracing on and off without commenting out
trace statements, and provides other useful things like HTML-ified
trace messages for CGI scripts and an easy way to trace out data
structures using Data::Dumper.

Math::BigInt::GMP is a replacement library for Math::BigInt::Calc that reimplements some of the Math::BigInt::Calc functions in XS. It can be used via: use Math::BigInt lib => 'GMP';

This package contains a replacement (drop-in) module for Math::BigInt's core, Math::BigInt::Calc.pm.

Math::GMP gives you access to the fast GMP library for fast big integer math.

This package is a Perl interface to famous library PARI for numerical/scientific/number-theoretic calculations. It allows use of most PARI functions as Perl functions, and (almost) seamless merging of PARI and Perl data.

This package is based on the package 'perl-Module-Pluggable' from project 'openSUSE:Factory'.

Provides a simple but, hopefully, extensible way of having 'plug-ins'
for your module. Obviously, this is not going to be the best possible
of solutions but it is convenient at the moment.

Essentially all it does is to export a method into your namespace that
looks through a search path for .pm files and turns those into class
names.

Optionally, it instantiates those classes for you.

Net::SSH::Perl is an all-Perl module implementing an SSH (Secure Shell) client.
It is compatible with both the SSH-1 and SSH-2 protocols.

Net::SSH::Perl enables you to simply and securely execute commands on remote
machines, and receive the STDOUT, STDERR, and exit status of that remote
command. It contains built-in support for various methods of authenticating
with the server (password authentication, RSA challenge-response
authentication, etc.). It completely implements the I/O buffering, packet
transport, and user authentication layers of the SSH protocol, and makes use of
external Perl libraries (in the Crypt:: family of modules) to handle encryption
of all data sent across the insecure network. It can also read your existing
SSH configuration files (/etc/ssh_config, etc.), RSA identity files, DSA
identity files, known hosts files, etc.

Persistence::Object::Simple provides persistence functionality to its objects.
Object definitions are stored as stringified perl data structures, generated
with Data::Dumper, that are amenable to manual editing and external processing
from outside the class interface.

This perl library allows you to manipulate patches programmatically by chaining together a variety of objects that read, manipulate, and output patch information