This module provides a c api for XS modules to hook into the callbacks of
"PL_check".

This module provides a c api for XS modules to hook into the execution of
perl opcodes.

Helper functions for op tree manipulation

Most programming languages have a native 'Boolean' data type. Perl does
not.

Perl has a simple and well known Truth System. The following scalar values
are false:

$false1 = undef;
$false2 = 0;
$false3 = 0.0;
$false4 = '';
$false5 = '0';

Every other scalar value is true.

This module provides basic Boolean support, by defining two special
objects: 'true' and 'false'.

The functions optionaly exported by this module allows you to open URLs in
the user browser.
A set of known commands per OS-name is tested for presence, and the first
one found is executed. With an optional parameter, all known commands are
checked.
The "open_browser" uses the "system()" function to execute the command. If
you want more control, you can get the command with the "open_browser_cmd"
or "open_browser_cmd_all" functions and then use whatever method you want
to execute it.

Capture::Tiny provides a simple, portable way to capture anything sent to
STDOUT or STDERR, regardless of whether it comes from Perl, from XS code or
from an external program. Optionally, output can be teed so that it is
captured while being passed through to the original handles. Yes, it even
works on Windows. Stop guessing which of a dozen capturing modules to use
in any particular situation and just use this one.

This module was heavily inspired by the IO::CaptureOutput manpage, which
provides similar functionality without the ability to tee output and with
more complicated code and API.

#-------------------------------------------------------------------------------
A chained accessor is one that always returns the object when called with
parameters (to set), and the value of the field when called with no arguments.

This module subclasses Class::Accessor in order to provide the same
mk_accessors interface.

"require EXPR" only accepts "Class/Name.pm" style module names, not
"Class::Name". How frustrating! For that, we provide "load_class
'Class::Name'".
It's often useful to test whether a module can be loaded, instead of
throwing an error when it's not available. For that, we provide
"try_load_class 'Class::Name'".
Finally, sometimes we need to know whether a particular class has been
loaded. Asking %%INC is an option, but that will miss inner packages and
any class for which the filename does not correspond to the package name.
For that, we provide "is_class_loaded 'Class::Name'".

Class::XSAccessor implements fast read, write and read/write accessors in
XS. Additionally, it can provide predicates such as "has_foo()" for
testing whether the attribute "foo" is defined in the object. It only
works with objects that are implemented as ordinary hashes.
Class::XSAccessor::Array implements the same interface for objects that
use arrays for their internal representation.

Who doesn't remember the first time they learned to copy and paste, and
generated an exponentially growing text document? Yes, that's right,
clipboards are magical.

With Clipboard.pm, this magic is now trivial to access, in a
cross-platform-consistent API, from your Perl code.

Config::Any provides a facility for Perl applications and libraries to load
configuration data from multiple different file formats. It supports XML, YAML,
JSON, Apache-style configuration, Windows INI files, and even Perl code.

The rationale for this module is as follows: Perl programs are deployed on many
different platforms and integrated with many different systems. Systems
administrators and end users may prefer different configuration formats than
the developers. The flexibility inherent in a multiple format configuration
loader allows different users to make different choices, without generating
extra work for the developers. As a developer you only need to learn a single
interface to be able to use the power of different configuration formats.

This module handles interaction with configuration files of the style used
by the version control system Git. It can both parse and modify these
files, as well as create entirely new ones.

Usually, when you need to create a subroutine that returns different values
in different contexts (list, scalar, or void), you write something like:

sub get_server_status {
my ($server_ID) = @_;

# Acquire server data somehow...
my %server_data = _ascertain_server_status($server_ID);

# Return different components of that data,
# depending on call context...
if (wantarray()) {
return @server_data{ qw(name uptime load users) };
}
if (defined wantarray()) {
return $server_data{load};
}
if (!defined wantarray()) {
carp 'Useless use of get_server_status() in void context';
return;
}
else {
croak q{Bad context! No biscuit!};
}
}

That works okay, but the code could certainly be more readable. In its
simplest usage, this module makes that code more readable by providing
three subroutines--'LIST()', 'SCALAR()', 'VOID()'--that are true only when
the current subroutine is called in the corresponding context:

use Contextual::Return;

sub get_server_status {
my ($server_ID) = @_;

# Acquire server data somehow...
my %server_data = _ascertain_server_status($server_ID);

# Return different components of that data
# depending on call context...
if (LIST) { return @server_data{ qw(name uptime load users) } }
if (SCALAR) { return $server_data{load} }
if (VOID) { print "$server_data{load}\n" }
else { croak q{Bad context! No biscuit!} }
}

A simple implementation of the RC4 algorithm, developed by RSA Security, Inc.
Here is the description from RSA's website:

RC4 is a stream cipher designed by Rivest for RSA Data Security (now RSA
Security). It is a variable key-size stream cipher with byte-oriented
operations. The algorithm is based on the use of a random permutation. Analysis
shows that the period of the cipher is overwhelmingly likely to be greater than
10100. Eight to sixteen machine operations are required per output byte, and
the cipher can be expected to run very quickly in software. Independent
analysts have scrutinized the algorithm and it is considered secure.

Aliasing is the phenomenon where two different expressions actually refer
to the same thing. Modifying one will modify the other, and if you take a
reference to both, the two values are the same.

Aliasing occurs in Perl for example in for-loops and sub-calls:

for $var ($x) {
# here $var is an alias to $x
}

foo($y);
sub foo {
# here $_[0] is an alias to $y
}

Data::Alias is a module that allows you to apply "aliasing semantics" to a
section of code, causing aliases to be made whereever Perl would normally
make copies instead. You can use this to improve efficiency and
readability, when compared to using references.

The exact details of aliasing semantics are below under the /DETAILS
manpage.

Given a list of scalars or reference variables, writes out their contents in
perl syntax. The references can also be objects. The contents of each variable
is output using the least number of Perl statements as convenient, usually only
one. Self-referential structures, closures, and objects are output correctly.

The return value can be evaled to get back an identical copy of the original
reference structure. In some cases this may require the use of utility subs
that Data::Dump::Streamer will optionally export.

This module is very similar in concept to the core module Data::Dumper, with
the major differences being that this module is designed to output to a stream
instead of constructing its output in memory (trading speed for memory), and
that the traversal over the data structure is effectively breadth first versus
the depth first traversal done by the others.

In fact the data structure is scanned twice, first in breadth first mode to
perform structural analysis, and then in depth first mode to actually produce
the output, but obeying the depth relationships of the first pass.

When searching through large amounts of data, it is often the case that a
result set is returned that is larger than we want to display on one page.
This results in wanting to page through various pages of data. The maths
behind this is unfortunately fiddly, hence this module.

The main concept is that you pass in the number of total entries, the number
of entries per page, and the current page number. You can then call methods
to find out how many pages of information there are, and what number the
first and last entries on the current page really are.

Authors:
--------
James Laver

This module is a simple visitor implementation for Perl values.

It has a main dispatcher method, 'visit', which takes a single perl value
and then calls the methods appropriate for that value.

It can recursively map (cloning as necessary) or just traverse most
structures, with support for per object behavior, circular structures,
visiting tied structures, and all ref types (hashes, arrays, scalars, code,
globs).

the Data::Visitor manpage is meant to be subclassed, but also ships with a
callback driven subclass, the Data::Visitor::Callback manpage.

DateTime is a class for the representation of date/time combinations, and
is part of the Perl DateTime project. For details on this project please
see the http://datetime.perl.org/ manpage. The DateTime site has a FAQ
which may help answer many "how do I do X?" questions. The FAQ is at the
http://datetime.perl.org/wiki/datetime/page/FAQ manpage.

It represents the Gregorian calendar, extended backwards in time before its
creation (in 1582). This is sometimes known as the "proleptic Gregorian
calendar". In this calendar, the first day of the calendar (the epoch), is
the first day of year 1, which corresponds to the date which was
(incorrectly) believed to be the birth of Jesus Christ.

The calendar represented does have a year 0, and in that way differs from
how dates are often written using "BCE/CE" or "BC/AD".

For infinite datetimes, please see the DateTime::Infinite module.

Devel::Caller - meatier versions of caller.

Devel::Declare can install subroutines called declarators which locally
take over Perl's parser, allowing the creation of new syntax.
This document describes how to create a simple declarator.

Perl's global destruction is a little tricky to deal with WRT finalizers
because it's not ordered and objects can sometimes disappear.

Writing defensive destructors is hard and annoying, and usually if global
destruction is happenning you only need the destructors that free up non
process local resources to actually execute.

For these constructors you can avoid the mess by simply bailing out if
global destruction is in effect.

Devel::LexAlias provides the ability to alias a lexical variable in a
subroutines scope to one of your choosing.

This module is a data dumper optimized for logging of arbitrary
parameters.