This module provides an extension to HTML::Template which allows
expressions in the template syntax.

Expression support includes comparisons, math operations, string
operations, and a mechanism to allow you to add your own functions at
runtime.

This is a just in time compiler for the HTML Template module. Makes the
use of templates very fast.

HTTP::Body parses chunks of HTTP POST data and supports application/octet-
stream, application/x-www-form-urlencoded, and multipart/form-data.

This class is for objects that represent a "cookie jar" -- that is, a
database of all the HTTP cookies that a given LWP::UserAgent object knows
about.

Cookies are a general mechanism which server side connections can use to
both store and retrieve information on the client side of the connection.
For more information about cookies refer to
and
. This module also implements the new
style cookies described in _RFC 2965_. The two variants of cookies are
supposed to be able to coexist happily.

Instances of the 'HTTP::Daemon' class are HTTP/1.1 servers that listen on a
socket for incoming requests. The 'HTTP::Daemon' is a subclass of
'IO::Socket::INET', so you can perform socket operations directly on it
too.

This module provides functions that deal the date formats used by the HTTP
protocol (and then some more). Only the first two functions, time2str() and
str2time(), are exported by default.

HTTP::DAV is a Perl API for interacting with and modifying content on
webservers using the WebDAV protocol. Now you can LOCK, DELETE and PUT
files and much more on a DAV-enabled webserver.

An 'HTTP::Message' object contains some headers and a content body. The
following methods are available:

* $mess = HTTP::Message->new

* $mess = HTTP::Message->new( $headers )

* $mess = HTTP::Message->new( $headers, $content )

This module provides a complete implementation of the HTTP content
negotiation algorithm specified in _draft-ietf-http-v11-spec-00.ps_ chapter
12. Content negotiation allows for the selection of a preferred content
representation based upon attributes of the negotiable variants and the
value of the various Accept* header fields in the request.

Provides a convenient way of setting up an CGI environment from an
HTTP::Request.

This module provide functions to extract various kind of meta information
from image files.

Inline lets you write Perl subroutines in other programming languages,
like C, C++, Java, Python, Tcl and even Assembly. You don't need to
compile anything. All the details are handled transparently, so you can
just run your Perl script like normal.

IO::Interface adds methods to IO::Socket objects that allows them to be
used to retrieve and change information about the network interfaces on
your system. In addition to the object-oriented access methods, you can
use a function-oriented style.

"IO::Multiplex" reduces the effort of managing multiple file handles.
It is a fancy front end to the "select" system call.

IO::Socket::INET6 provides an object interface to creating and using
sockets in either AF_INET or AF_INET6 domains. It is built upon the
IO::Socket interface and inherits all the methods defined by IO::Socket.

This module is a true drop-in replacement for IO::Socket::INET that uses
SSL to encrypt data before it is transferred to a remote server or client.
IO::Socket::SSL supports all the extra features that one needs to write a
full-featured SSL client or server application: multiple SSL contexts,
cipher selection, certificate verification, and SSL version selection. As
an extra bonus, it works perfectly with mod_perl.

If you have never used SSL before, you should read the appendix labelled
'Using SSL' before attempting to use this module.

If you have used this module before, read on, as versions 0.93 and above
have several changes from the previous IO::Socket::SSL versions (especially
see the note about return values).

If you are using non-blocking sockets read on, as version 0.98 added better
support for non-blocking.

If you are trying to use it with threads see the BUGS section.

IO::String is an IO::File (and IO::Handle) compatible class that reads
or writes data from in-core strings.

I/O on in-core objects like strings and arrays

IPC::Run allows you run and interact with child processes using files,
pipes, and pseudo-ttys. Both system()-style and scripted usages are
supported and may be mixed. Like-wise, functional and OO API styles are
both supported and may be mixed.

This module is meant to be the definitive implementation of iterators, as
popularized by Mark Jason Dominus's lectures and recent book (_Higher Order
Perl_, Morgan Kauffman, 2005).

An "iterator" is an object, represented as a code block that generates the
"next value" of a sequence, and generally implemented as a closure. When
you need a value to operate on, you pull it from the iterator. If it
depends on other iterators, it pulls values from them when it needs to.
Iterators can be chained together (see the Iterator::Util manpage for
functions that help you do just that), queueing up work to be done but _not
actually doing it_ until a value is needed at the front end of the chain.
At that time, one data value is pulled through the chain.

Contrast this with ordinary array processing, where you load or compute all
of the input values at once, then loop over them in memory. It's analogous
to the difference between looping over a file one line at a time, and
reading the entire file into an array of lines before operating on it.

Iterator.pm provides a class that simplifies creation and use of these
iterator objects. Other 'Iterator::' modules (see the /"SEE ALSO" manpage)
provide many general-purpose and special-purpose iterator functions.

Some iterators are infinite (that is, they generate infinite sequences),
and some are finite. When the end of a finite sequence is reached, the
iterator code block should throw an exception of the type
'Iterator::X::Am_Now_Exhausted'; this is usually done via the the /is_done
manpage function.. This will signal the Iterator class to mark the object
as exhausted. The the /is_exhausted manpage method will then return true,
and the the /isnt_exhausted manpage method will return false. Any further
calls to the the /value manpage method will throw an exception of the type
'Iterator::X::Exhausted'. See the /DIAGNOSTICS manpage.

Note that in many, many cases, you will not need to explicitly create an
iterator; there are plenty of iterator generation and manipulation
functions in the other associated modules. You can just plug them together
like building blocks.

This module implements many useful functions for creating and manipulating
iterator objects.

An "iterator" is an object, represented as a code block that generates the
"next value" of a sequence, and generally implemented as a closure. For
further information, including a tutorial on using iterator objects, see
the the Iterator manpage documentation.

A Client interface for LDAP servers.

The libwww-perl collection is a set of Perl modules which provides a
simple and consistent application programming interface to the World-Wide
Web. The main focus of the library is to provide classes and functions
that allow you to write WWW clients. The library also contain modules that
are of more general use and even classes that help you implement simple
HTTP servers.

perl-libxml-perl is a collection of Perl modules for working with XML.

This module use the a modified version of the Porter Stemming Algorithm to
return a stemmed words.

Authors:
--------
Sébastien Darribere-Pleyt,