MooseX::NonMoose allows for easily subclassing non-Moose classes with Moose, taking care of the details connected with doing this, such as setting up proper inheritance from Moose::Object and installing (and inlining, at make_immutable time) a constructor that makes sure things like BUILD methods are called. It tries to be as non-intrusive as possible.

The Benchmark::Timer class allows you to time portions of code conveniently, as well as benchmark code by allowing timings of repeated trials. It is perfect for when you need more precise information about the running time of portions of your code than the Benchmark module will give you, but don't want to go all out and profile your code.

This module causes any warnings during testing to be captured and stored. It automatically adds an extra test that will run when your script ends to check that there were no warnings. If there were any warnings, the test will fail and output diagnostics of where, when and what the warning was, including a stack trace of what was going on when it occurred.

Test::MockModule lets you temporarily redefine subroutines in other packages for the purposes of unit testing. A Test::MockModule object is set up to mock subroutines for a given module. The mocked object remembers the original subroutine so it can be easily restored. This happens automatically when all MockModule objects for the given module go out of scope, or when you unmock() the subroutine.

This module allows you to build a variable package that contains a package template and can use it to build variant packages at runtime. Your variable package will export a subroutine which will build a variant package, combining its arguments with the template, and return the name of the new variant package. The implementation does not care about what kind of packages it builds, be they simple function exporters, classes, singletons or something else.

The fundamental task of the autoformat subroutine is to identify and rearrange independent paragraphs in a text. Paragraphs typically consist of a series of lines containing at least one non-whitespace character, followed by one or more lines containing only optional whitespace. This is a more liberal definition than many other formatters use: most require an empty line to terminate a paragraph. Paragraphs may also be denoted by bulleting, numbering, or quoting (see the following sections).

This is a collection of perl classes for reading and writing directed graphs in a variety of file formats. The graphs are represented in Perl using Jarkko Hietaniemi's Graph classes.

There are two base classes. Graph::Reader is the base class for classes which read a graph file and create an instance of the Graph class. Graph::Writer is the base class for classes which take an instance of the Graph class and write it out in a specific file format.

This module provides an XPath engine, that can be re-used by other modules/classes that implement trees.

In order to use the XPath engine, nodes in the user module need to mimic DOM nodes. The degree of similitude between the user tree and a DOM dictates how much of the XPath features can be used. A module implementing all of the DOM should be able to use this module very easily (you might need to add the cmp method on nodes in order to get ordered result sets).

This module can test routines that manipulate random numbers by providing a known output from rand. Given a list of seeds with srand, it will return each in turn. After seeded random numbers are exhausted, it will always return 0. Seed numbers must be of a form that meets the expected output from rand as called with no arguments: they must be between 0 (inclusive) and 1 (exclusive). In order to facilitate generating and testing a nearly-one number, this module exports the function oneish, which returns a number just fractionally less than one.

This module provides various type-testing functions. These are intended for functions that care what type of data they are operating on. There are two flavours of function. Functions of the first flavour provide type classification only. Functions of the second flavour also check that an argument is of an expected type. The type enforcement functions handle only the simplest requirements for arguments of the types handled by the classification functions. Enforcement of more complex types may be built using the classification functions, or it may be more convenient to use a module designed for the more complex job, such as Params::Validate

Async::Interrupt implements a single feature only of interest to advanced perl modules, namely asynchronous interruptions (think "UNIX signals", which are very similar).

Sometimes, modules wish to run code asynchronously (in another thread, or from a signal handler), and then signal the perl interpreter on certain events. One common way is to write some data to a pipe and use an event handling toolkit to watch for I/O events. Another way is to send a signal. Those methods are slow, and in the case of a pipe, also not asynchronous - it won't interrupt a running perl interpreter.

This module implements asynchronous notifications that enable you to signal running perl code from another thread, asynchronously, and sometimes even without using a single syscall.

Multidimensional disables multidimensional array emulation.

This package provides templated software licenses.

Text::SimpleTable draws simple ASCII tables.

Data::SExpression parses Lisp S-Expressions into Perl data structures.

This module exports three test functions and four diff-style functions.

This module allows you to wrap OP check callbacks.

This module provides various portable helper functions for module building modules.

This module implements Spreadsheet::XLSX parsing Microsoft Excel 2007 xlsx files.

This module is a Catalyst view class for the Template Toolkit.

String::Copyright Parses common styles of copyright statements and serializes in normalized format.

This package provides an efficient mechanism to look up ranges in Interval Trees.

Carp::Assert::More is a set of handy assertion functions for Perl.