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.
The Battle.net client library.
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.
This module acts as glue between IO::All and LWP, so that files can be read and
written through the network using the convenient IO:All interface. Note that
this module is not used directly: you just use IO::All, which knows when to
autoload IO::All::HTTP, IO::All::HTTPS, IO::All::FTP, or IO::All::Gopher, which
implement the specific protocols based on IO::All::LWP.
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.
Calling Perl's in-built system() function is easy, determining if it
was successful is hard. Let's face it, $? isn't the nicest variable
in the world to play with, and even if you do check it, producing a
well-formatted error string takes a lot of work.
IPC::System::Simple takes the hard work out of calling external
commands.