This module provides a flexible calling interface to some frequently-performed string conversion functions, including applying and expanding standard C/Unix-style backslash escapes like and , wrapping and removing double-quotes, and truncating to fit within a desired length.

This module makes some new features of the Perl 5.14.0 C API available to XS modules running on older versions of Perl. The features are centred around the function cv_set_call_checker, which allows XS code to attach a magical annotation to a Perl subroutine, resulting in resolvable calls to that subroutine being mutated at compile time by arbitrary C code. This module makes cv_set_call_checker and several supporting functions available.

This module can serve as a transparent interface to any TIEHASH package that is required to store arbitrary perl data, including nested references. Thus, this module can be used for storing references and other arbitrary data within DBM databases.

Exporter::Tiny supports many of Sub::Exporter's external-facing features including renaming imported functions with the `-as`, `-prefix` and `-suffix` options; explicit destinations with the `into` option; and alternative installers with the `installer` option. But it's written in only about 40% as many lines of code and with zero non-core dependencies.

This package provides an ASCII mapping for the eucJP encoding.

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

This Perl module allows you to split data into records by not only specifying what you wish to split the data on, but also by specifying an "unless" regular expression. If the text in question matches the "unless" regex, it will not be split there. This allows us to do things like split on newlines unless newlines are embedded in quotes.

Template::Timer provides inline profiling of the template processing in Perl code.

List::SomeUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util.

All of the below functions are implementable in only a couple of lines of Perl code. Using the functions from this module however should give slightly better performance as everything is implemented in C. The pure-Perl implementation of these functions only serves as a fallback in case the C portions of this module couldn't be compiled on this machine.

Pod::Spell is a Pod formatter whose output is good for spellchecking.

Pod::Spell is rather like Pod::Text, except that it doesn't put much effort into actual formatting, and it suppresses things that look like Perl symbols or Perl jargon (so that your spellchecking program won't complain about mystery words like "$thing" or "Foo::Bar" or "hashref").

Config::Tiny is a Perl class to read and write .ini style configuration files with as little code as possible, reducing load time and memory overhead.

This module is primarily for reading human written files, and anything we write shouldn't need to have documentation/comments. If you need something with more power move up to Config::Simple, Config::General or one of the many other Config::* modules.

Log::Report combines three tasks which are closely related in one: logging, exceptions, and translations.

This module provides an interface to layout and image generation of directed and undirected graphs in a variety of formats (PostScript, PNG, etc.) using the dot, neato, twopi, circo, and fdp programs from the Graphviz project. This package is deprecated in favour of GraphViz2.

Path::Iterator::Rule iterates over files and directories to identify ones matching a user-defined set of rules. The API is based heavily on File::Find::Rule, but with more explicit distinction between matching rules and options that influence how directories are searched. A Path::Iterator::Rule object is a collection of rules (match criteria) with methods to add additional criteria. Options that control directory traversal are given as arguments to the method that generates an iterator.

A summary of features for comparison to other file finding modules:

• provides many helper methods for specifying rules

• offers (lazy) iterator and flattened list interfaces

• custom rules implemented with callbacks

• breadth-first (default) or pre- or post-order depth-first searching

• follows symlinks (by default, but can be disabled)

• directories visited only once (no infinite loop; can be disabled)

• doesn't chdir during operation

• provides an API for extensions

As a convenience, the PIR module is an empty subclass of this one that is less arduous to type for one-liners.

Data::Section::Simple is a simple module to extract data from __DATA__ section of the file.

Dates are complex enough without times and timezones. This module may be used to create simple date objects. It handles validation, interval arithmetic, and day-of-week calculation. It does not deal with hours, minutes, seconds, and time zones.

Data::OptList provides a simple syntax for name/value option pairs.

This module provides a small, fast utility for working with file paths.

POSIX::strftime::Compiler provides GNU C library compatible strftime(3). But this module is not affected by the system locale. This feature is useful when you want to write loggers, servers, and portable applications.

CPAN::DistnameInfo uses heuristics to extract the distribution name and version from filenames.

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.

Text::SimpleTable draws simple ASCII tables.

This module provides routines for parsing date string into time values and formatting dates into ASCII strings.