Line wrapping module with support for multibyte, fullwidth, and combining
characters and languages without whitespaces between words.

This module implements a least recently used (LRU) cache in memory
through a tie interface.

This module has been created to act as a drop-in replacement for modules
that tie straight perl hashes to disk, like 'DB_File'. When the running
system does not have enough memory to hold large hashes, and disk-tieing
won't work because there is not enough space, it works quite well to tie
the hash to a database, which preferable runs on a different server.

This module ties a hash to a database table using *only* a 'key' and a
'value' field. If no tables specification is passed, this will create a
temporary table with 'h_key' for the key field and a 'h_value' for the
value field.

I think it would make sense to merge the functionality that this module
provides into 'Tie::DBI'.

If you have been led to believe that associative arrays in Perl do not
preserve order, and if you have ever craved that feature, this module
is for you.

This module adds the ability to quickly create new types of tie objects without creating a complete class. It does so in such a way as to try and make the programmers life easier when it comes to single-use ties.

The 'Tie::Simple' package is actually a front-end to other classes which really do all the work once tied, but this package does the work to automatically figure out what you're trying to do.

A the Time::Clock manpage object is a twenty-four hour clock with
nanosecond precision and wrap-around. It is a clock only; it has absolutely
no concept of dates. Vagaries of date/time such as leap seconds and
daylight savings time are unsupported.

When a the Time::Clock manpage object hits 23:59:59.999999999 and at least
one more nanosecond is added, it will wrap around to 00:00:00.000000000.
This works in reverse when time is subtracted.

the Time::Clock manpage objects automatically stringify to a user-definable
format.

This module provides functions for expressing durations in rounded or
exact terms.

Perl modules providing various time functions.

Period.pm is a Perl module that contains code for dealing with time
periods. Currently, there is only one function in this module. That
function is called inPeriod().

Date::Parse provides two routines for parsing date strings into time values.

str2time(DATE [, ZONE])

str2time parses DATE and returns a unix time value, or undef upon failure.
ZONE, if given, specifies the timezone to assume when parsing if the date
string does not specify a timezome.

strptime(DATE [, ZONE])

strptime takes the same arguments as str2time but returns an array of values
($ss,$mm,$hh,$day,$month,$year,$zone). Elements are only defined if they
could be extracted from the date string. The $zone element is the timezone
offset in seconds from GMT. An empty array is returned upon failure.

Perl Tk is an enhancement for Perl. It combines the well structured
graphical library Tk with the powerful scripting language Perl.

This module implements a Canvas-based clock widget for perl-Tk with lots of
options to change the appearance.

Both analog and digital clocks are implemented.

This class encapsulates/makes/manipulates objects that represent nodes
in a tree structure. The tree structure is not an object itself, but is
emergent from the linkages you create between nodes. This class
provides the methods for making linkages that can be used to build up a
tree, while preventing you from ever making any kinds of linkages which
are not allowed in a tree (such as having a node be its own mother or
ancestor, or having a node have two mothers).

The Unicode::Map8 class implement efficient mapping tables between
8-bit character sets and 16-bit character sets like Unicode. The tables
are efficient both in terms of space allocated and translation speed.
The 16-bit strings is assumed to use network byte order.

A Unicode::String object represents a sequence of Unicode characters.
The Unicode Standard is a fixed-width, uniform encoding scheme for
written characters and text. This encoding treats alphabetic
characters, ideographic characters, and symbols identically, which
means that they can be used in any mixture and with equal facility.
Unicode is modeled on the ASCII character set, but uses a 16-bit
encoding to support full multilingual text.

Class names in Perl often don't sound great when spoken, or look good when
written in prose. For this reason, we tend to say things like "customer" or
"basket" when we are referring to 'My::Site::User::Customer' or
'My::Site::Shop::Basket'. We thought it would be nice if our classes knew
what we would prefer to call them.

This module will add a 'moniker' (and 'plural_moniker') method to
'UNIVERSAL', and so to every class or module.

This module implements the URI class. Objects of this class represent
"Uniform Resource Identifier references" as specified in RFC 2396 (and
updated by RFC 2732).

URI objects can be used to access and manipulate the various
components that make up these strings. There are also methods to
combine URIs in various ways.

This module does one thing: Finds URIs and URLs in plain text. It finds
them quickly and it finds them all (or what URI::URL considers a URI to
be.) It only finds URIs which include a scheme (http:// or the like).

Author: Michael G Schwern with insight from
Uri Gutman, Greg Bacon, Jeff Pinyan, Roderick Schertler and others.

A patch to Perl 5.005_55 by the author implements a core API for weak
references. This module is a Perl-level interface to that API, allowing
weak references to be created in Perl.

A weak reference is just like an ordinary Perl reference except that it
isn't included in the reference count of the thing referred to. This
means that once all references to a particular piece of data are weak,
the piece of data is freed and all the weak references are set to
undef. This is particularly useful for implementing circular data
structures without memory leaks or caches of objects.

This module parses _/robots.txt_ files as specified in "A Standard for
Robot Exclusion", at Webmasters
can use the _/robots.txt_ file to forbid conforming robots from accessing
parts of their web site.

XML::Bare - A minimal XML parser that uses C to generate a folded perl
hash.

This package implements XML as the author thinks it should be, not as
the standard says. Means this parser is not XML conform. So be very
careful if you use this package, the result does not need to be the one
you would expect.

This module extends the XML::Parser module by Clark Cooper. The XML::Parser
module is built on top of XML::Parser::Expat, which is a lower level
interface to James Clark's expat library.

This module implements a Perl interface to the Gnome libxml2 library which
provides interfaces for parsing and manipulating XML files. This module allows
Perl programmers to make use of the highly capable validating XML parser and
the high performance DOM implementation.