Simply loading this module makes your constructors "strict". If your constructor is called with an attribute init argument that your class does not declare, then it calls Moose->throw_error().

Ref::Util::XS is the XS implementation of Ref::Util, which provides several functions to help identify references in a more convenient way than the usual approach of examining the return value of ref.

Text::CSV_XS provides facilities for the composition and decomposition of comma-separated values. An instance of the Text::CSV_XS class will combine fields into a CSV string and parse a CSV string into fields. The module accepts either strings or files as input and support the use of user-specified characters for delimiters, separators, and escapes.

Pegex is an Acmeist parser framework. It allows you to easily create parsers that will work equivalently in lots of programming languages. The inspiration for Pegex comes from the parsing engine upon which the postmodern programming language Perl 6 is based on. Pegex brings this beauty to the other justmodern languages that have a normal regular expression engine available.

Crypt::DES is an XS-based implementation of the DES cryptography algorithm. The module implements the Crypt::CBC interface which has blocksize, keysize, encrypt and decrypt functions.

This package provides an API for dealing where the case where you have several long texts (and/or binary blobs) that you wish to load from the code (e.g: for the "want"/expected values of tests) and you wish to conveniently edit them, track them and maintain them. Using this package, you can put each in a separate file in a directory, create a manifest file listing all valid filenames/key, and load from there.

This package enables you to do generic message logging throughout programs and projects. Every message will be logged with stacktraces, timestamps and so on. You can use built-in handlers immediately, or after the fact when you inspect the error stack. It is highly configurable and lets you even provide your own handlers for dealing with messages.

Eksblowfish is a variant of the Blowfish cipher, modified to make the key setup very expensive. This doesn't make it significantly cryptographically stronger but is intended to hinder brute-force attacks. Eksblowfish is a parameterised (family-keyed) cipher. It takes a cost parameter that controls how expensive the key scheduling is. It also takes a family key, known as the "salt". Cost and salt parameters together define a cipher family. Within each family, the key determines the encryption function. This distribution also includes an implementation of bcrypt, the Unix crypt() password hashing algorithm based on Eksblowfish.

Log::Any::Adapter::Log4perl provides a Log::Any adapter using Log::Log4perl for logging.

This package provides procedures to create read-only scalars, arrays, and hashes.

Modern::Perl provides a simple way to enable multiple, by now, standard libraries in a Perl program.

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

The Term::Animation Perl module provides a framework to produce sprite animations using ASCII art. Each ASCII 'sprite' is given one or more frames, and placed into the animation as an 'animation entity'. An animation entity can have a callback routine that controls the position and frame of the entity. The module can also do collision detection between entities.

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".

Mozilla::CA provides a copy of Mozilla's bundle of Certificate Authority certificates in a form that can be consumed by modules and libraries based on OpenSSL.

Socket::MsgHdr provides advanced socket messaging operations via sendmsg and recvmsg.

It also allows manipulating ancillary data or so-called control information (cmsghdr). This ancillary data may be used for file descriptor passing, IPv6 operations, and a host of implementation-specific extensions.

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

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 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.

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.

This package allows you to stop processing the entire test suite after the first failure, instead of going all the way through it.

The Specio distribution provides classes for representing type constraints and coercion, along with syntax sugar for declaring them. Note that this is not a proper type system for Perl. Nothing in this distribution will magically make the Perl interpreter start checking a value's type on assignment to a variable. In fact, there's no built-in way to apply a type to a variable at all. Instead, you can explicitly check a value against a type, and optionally coerce values to that type.

This is yet another implementation of Term::Size. Now in pure Perl, with the exception of a C probe run at build time.

Exception::Class allows you to declare exception hierarchies in your modules in a "Java-esque" manner.