A shared memory cache through an mmap'ed file. It's core is written in C for performance. It uses fcntl locking to ensure multiple processes can safely access the cache at the same time. It uses a basic LRU algorithm to keep the most used entries in the cache.

This module allows for anonymous packages that are independent of the main namespace and only available through an object instance, not by name.

This module adds the ability to quickly create new types of tie objects without creating a complete class. It does so in such a way as to try and make the programmers life easier when it comes to single-use ties that I find myself wanting to use from time-to-time.

The Tie::Simple package is actually a front-end to other classes which really do all the work once tied, but this package does the dwimming to automatically figure out what you're trying to do.

Devel::GlobalDestruction provides a function returning the equivalent of "${^GLOBAL_PHASE} eq 'DESTRUCT'" for older perls.

This module attempts to emulate the behavior of Class::Accessor::Fast as accurately as possible using the Moose attribute system. The public API of Class::Accessor::Fast is wholly supported, but the private methods are not.

This Perl modules implements Future::Queue, a class providing a simple FIFO queue that stores arbitrary Perl values. Values may be added into the queue using the push method, and retrieved from it using the shift method.

This package provides some basic statistics on numerical vectors. All the subroutines can take a reference to the vector to be operated on.

Class::Data::Inheritable is for creating accessor/mutators to class data. That is, if you want to store something about your class as a whole (instead of about a single object). This data is then inherited by your subclasses and can be overridden.

This module implements an expiry policy for Memoize that follows LRU semantics, that is, the last n results, where n is specified as the argument to the CACHESIZE parameter, will be cached.

This module provides an XS implementation for portions of Class::Load.

This package provides tools for sorting and comparing Unicode data.

This module converts Perl data structures to JSON and vice versa.

This module implements a subset of the YAML specification for use in reading and writing CPAN metadata files like META.yml and MYMETA.yml.

Module::Refresh provides ways to refresh %INC files when updated on disk.

This module tries to make it easy to build Perl extensions that use functions and typemaps provided by other perl extensions. This means that a perl extension is treated like a shared library that provides also a C and an XS interface besides the perl one.

Hash::MultiValue is an object (and a plain hash reference) that may contain multiple values per key, inspired by MultiDict of WebOb.

This module allows you to rewrite strings based on a set of known prefixes.

When subclassing a class, you may occasionally want to dispatch control to the superclass---at least conditionally and temporarily. This module provides nicer equivalents to the native Perl syntax for calling superclasses, along with a universal super method to determine a class' own superclass, and better support for run-time mix-ins and roles.

Reply is a lightweight, extensible REPL for Perl. It is plugin-based (see Reply::Plugin), and through plugins supports many advanced features such as coloring and pretty printing, readline support, and pluggable commands.

This module implement a UDP client for the statsd statistics collector daemon in use at Etsy.com.

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.

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

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

This module creates a customized, highly efficient parameter checking subroutine. It can handle named or positional parameters, and can return the parameters as key/value pairs or a list of values. In addition to type checks, it also supports parameter defaults, optional parameters, and extra "slurpy" parameters.