This module will inject base classes to your module using the Class::C3 method resolution order.

Set::IntSpan manages sets of integers. It is optimized for sets that have long runs of consecutive integers.

Parallel::ForkManager is intended for use in operations that can be done in parallel where the number of processes to be forked off should be limited.

MooseX::Object::Pluggable makes your classes pluggable.

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

This module first checks to see if either Cpanel::JSON::XS or JSON::XS is already loaded, in which case it uses that module. Otherwise it tries to load Cpanel::JSON::XS, then JSON::XS, then JSON::PP in order, and either uses the first module it finds or throws an error.

This module implements the algorithm for the solution of Bezier curves as presented by Robert D Miller in Graphics Gems V, "Quick and Simple Bezier Curve Drawing".

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

This module tries to make install path resolution as easy as possible.

Config::Grammar is a module to parse configuration files. The configuration may consist of multiple-level sections with assignments and tabular data.

This module attempts to work around people calling UNIVERSAL::can() as a function, which it is not.

This package consists of a Perl module for date calculations based on the Gregorian calendar, thereby complying with all relevant norms and standards: ISO/R 2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable).

List::Compare provides a module to perform comparative operations on two or more lists. Provided operations include intersections, unions, unique elements, complements and many more.

This module provides some XS functions to assist in writing syntax modules that provide new perl-visible syntax, primarily for authors of keyword plugins using the PL_keyword_plugin hook mechanism.

This package transparently speeds up functions by caching return values, trading space for time.

This is a module for computing the difference between two files, two strings, or any other two lists of things. It uses an intelligent algorithm similar to (or identical to) the one used by the Unix "diff" program. It is guaranteed to find the *smallest possible* set of differences.

This module understands the formats used by PostgreSQL for its DATE, TIME, TIMESTAMP, and INTERVAL data types. It can be used to parse these formats in order to create DateTime or DateTime::Duration objects, and it can take a DateTime or DateTime::Duration object and produce a string representing it in a format accepted by PostgreSQL.

Sys::Syscall allows one to use epoll and sendfile system calls from Perl. Support is mostly Linux-only for now, but other syscalls/OSes are planned for the future.

Encode module provides the interface between Perl strings and the rest of the system. Perl strings are sequences of characters.

Meta::Builder is designed to be a generic tool for writing Meta objects. Unlike specialized tools, Meta::Builder makes no assumptions about what metrics you will care about. Meta::Builder also makes it simple for others to extend your meta-object based tools by providing hooks for other packages to add metrics to your meta object.

This module implements most of `strptime(3)`, the POSIX function that is the reverse of `strftime(3)`, for `DateTime`. While `strftime` takes a `DateTime` and a pattern and returns a string, `strptime` takes a string and a pattern and returns the `DateTime` object associated.

Sub::Exporter is an incredibly powerful module, but with that power comes great responsibility, as well as some runtime penalties. This module is a "Sub::Exporter" wrapper that will let your users just use Exporter if all they are doing is picking exports, but use "Sub::Exporter" if your users try to use "Sub::Exporter"'s more advanced features, like renaming exports, if they try to use them.

The Readonly module is an effective way to create non-modifiable variables. However, it's relatively slow.

The reason it's slow is that is implements the read-only-ness of variables via tied objects. This mechanism is inherently slow. Perl simply has to do a lot of work under the hood to make tied variables work.

This module corrects the speed problem, at least with respect to scalar variables. When Readonly::XS is installed, Readonly uses it to access the internals of scalar variables. Instead of creating a scalar variable object and tying it, Readonly simply flips the SvREADONLY bit in the scalar's FLAGS structure.

This is a meta-package that installs the CPAN dependencies of the Freecell Solver test suite.