A heap is a partially sorted structure where it's always easy to extract the
smallest element. If the collection of elements is changing dynamically, a heap
has less overhead than keeping the collection fully sorted.
The order in which equal elements get extracted is unspecified.
The main order relations supported by this module are "<" (numeric compare) and
"lt" (string compare).
The internals of the module do nothing with the elements inserted except
inspecting the key. This means that if you for example store a blessed object,
that's what you will get back on extract. It's also ok to keep references to the
elements around and make changes to them while they are in the heap as long as
you don't change the key.
Heap::Simple itself is just a loader for the code that will actually implement
the functionality mentioned above. You will need to install something like
Heap::Simple::XS or Heap::Simple::Perl to be able to actually do anything.
This module allows you to run a subprocess and redirect stdin, stdout,
and/or stderr to files and perl data structures. It aims to satisfy
99% of the need for using system()/qx``/open3() with a simple,
extremely Perlish API and none of the bloat and rarely used features of
IPC::Run.
This module implements asynchronous I/O using whatever means your
operating system supports.
Asynchronous means that operations that can normally block your
program (e.g. reading from disk) will be done asynchronously: the
operation will still block, but you can do something else in the
meantime. This is extremely useful for programs that need to stay
interactive even when doing heavy I/O (GUI programs, high performance
network servers etc.), but can also be used to easily do operations in
parallel that are normally done sequentially, e.g. stat'ing many files,
which is much faster on a RAID volume or over NFS when you do a number
of stat operations concurrently.
While most of this works on all types of file descriptors (for example
sockets), using these functions on file descriptors that support
nonblocking operation (again, sockets, pipes etc.) is very inefficient
or might not work (aio_read fails on sockets/pipes/fifos). Use an
event loop for that (such as the Event module): IO::AIO will naturally
fit into such an event loop itself.
IPC::ShareLite provides a simple interface to shared memory, allowing data to
be efficiently communicated between processes. Your operating system must
support SysV IPC (shared memory and semaphores) in order to use this module.
IO::All - IO::All combines all of the best Perl IO modules
IO::All combines all of the best Perl IO modules into a single Spiffy object
oriented interface to greatly simplify your everyday Perl IO idioms.
It exports a single function called io, which returns a new IO::All object.
And that object can do it all!
IO::Any aims to provide read/write anything. It tries to guess what the
"anything" is based on some rules.
IPC::Signal - Utility functions dealing with signals
This module contains utility functions for dealing with signals.
This collection of modules allows programs to be written that perform
asynchronous filehandle IO operations. A typical program using them would
consist of a single subclass of IO::Async::Set to act as a container for a
number of IO::Async::Notifier objects (or subclasses thereof). The set itself is
responsible for checking read- or write-readiness, and informing the notifiers
of these conditions. The notifiers then perform whatever work is required on
these conditions, by using subclass methods or callback functions.
IO::Callback provides an easy way to produce a phoney read-only
filehandle that calls back to your own code when it needs data to
satisfy a read. This is useful if you want to use a library module
that expects to read data from a filehandle, but you want the data to
come from some other source and you don't want to read it all into
memory and use IO::String.
The C<IO::Capture> Module defines an abstract base class that can be
used to build modules that capture output being sent on a filehandle
such as STDOUT or STDERR.
Several modules that come with the distribution, do just that.
(I.e., Capture STDOUT and STDERR) See L<IO::Capture::Overview> for a
discussion of these modules and examples of how to build a module to
sub-class from C<IO::Capture> yourself. If after reading the overview,
you would like to build a class from C<IO::Capture>, look here for
details on the internals.