CPANscan

Term::ANSIEncode is a lightweight Perl module that provides a simple markup language for generating colored and formatted terminal output, turning tokens like [% RED %] and [% B_RGB 255,0,0 %] into ANSI escape sequences. It supports cursor movement and screen control, text attributes such as bold and underline, foreground and background colors including 24-bit RGB, boxed frames, horizontal rules, word wrapping and simple macros, so you can build banners, dialog-style boxes, status displays and other rich text UIs for terminals. Use it by creating a Term::ANSIEncode object and passing your markup to its ansi_output method, or try the companion "ansi-encode" executable which can list available tokens with the -t option. A UTF-8 capable terminal is recommended for special graphical and international characters.

Common::CodingTools is a lightweight toolkit for everyday Perl programming that bundles handy constants and small utility functions you can import as needed. It defines readable boolean and state constants like TRUE, FALSE, ON, OFF, ACTIVE, INACTIVE and others so your code reads more clearly. It also provides common helpers you often miss in core Perl such as slurp_file for reading a whole file, ltrim/rtrim/trim for trimming whitespace, center for simple text alignment, tfirst for title-casing text and a leet-style uc_lc function, plus a schwartzian_sort implementation for faster custom sorts. You can import everything or pick named tags to only bring in the constants or specific function groups, making it handy for scripts and small projects that want a consistent, easy-to-use set of utilities.

Test::Mockingbird is an advanced Perl testing helper that lets you replace, observe, and inject code during tests to simplify isolation and verification. You can install mocks to override methods, create spies that record calls while preserving originals, inject mock dependencies into modules, and use helpers such as mock_return, mock_exception, mock_sequence and mock_once to express common test scenarios. Scoped mocks return a guard that automatically restores the original implementation when it goes out of scope and restore_all, restore and unmock let you revert changes manually. Built in diagnostics provide structured and human readable reports of active mock layers and their installation locations without altering test behaviour so you can debug complex mock stacking safely. The project is hosted on GitHub and the distribution permits personal use under GPL2 while other uses require contacting the author, so check the licence for commercial use.

LTSV::LINQ is a Pure Perl library that brings a LINQ-style, fluent query API to LTSV (labeled tab-separated) logs and in-memory arrays, letting you filter, project, group, join, sort, aggregate and transform records with readable chained calls. It uses an iterator-based, lazy evaluation model so most operations stream one record at a time and use constant memory, which makes it practical for very large log files, and it implements about 60 LINQ-like methods including Where (code-ref or simple key=>value DSL), Select, Distinct, Join, GroupBy and many aggregation and conversion helpers. The module is implemented in pure Perl with no non-core dependencies and deliberately supports very old Perl versions back to 5.005_03. Be aware that some operations are eager and materialize data into memory, for example OrderBy, GroupBy, Join and full conversions, and FromLTSV holds the file handle open until the iterator is fully consumed. The DSL is convenient for simple string-equality filters only, so use code references for numeric, regex or OR logic, and remember query objects are single-pass iterators so call ToArray to snapshot results you need to reuse. Overall it is a compact, expressive tool for readable, memory-efficient LTSV log analysis and transformation across a wide range of Perl environments.

IO::K8s is a Perl toolkit that models Kubernetes API objects as typed Perl objects and provides serialization, deserialization and validation for manifests. You can create resources programmatically, load and validate YAML or a Perl DSL, inflate JSON or plain hashes into typed objects, and export back to YAML or JSON suitable for kubectl. It supports Custom Resource Definitions either by writing small CRD classes or by auto-generating classes from a cluster OpenAPI spec, and you can merge external resource-map providers like Cilium so multiple providers coexist without confusion. The library enforces Kubernetes' strict types so integers, booleans and nested structures are encoded correctly to avoid API rejections, and it integrates with Kubernetes::REST for request/response objects. Recent fixes improved boolean handling and YAML serialization so JSON boolean values and scalar-reference booleans now round-trip and serialize as true/false as expected.

Graphics::Toolkit::Color is a high level Perl toolkit for creating, converting and generating colors and palettes for screen use. It gives you a single read only color object you can construct from names, hex codes, CSS strings or numeric tuples and a lightweight color helper for quick use. You can convert between many color spaces, ask for numeric or named representations, check gamut validity, measure perceptual distance, mix and invert colors, and produce complements, gradients and clusters to build palettes for UIs, visualizations or design tasks. RGB is used internally but perceptual spaces like CIELAB and OKLAB are supported for more human‑accurate results and you can control ranges, precision and output formats for easy serialization. Methods return new objects so chaining is simple. Some extended name schemes require additional modules and the API reports errors as return values rather than exceptions.

App::karr is a small Perl application that implements a Kanban-style assignment and responsibility registry for teams. It helps capture who owns which tasks or cards and makes it easier to assign, track, and audit responsibilities in a lightweight, code-friendly way rather than introducing heavyweight project tooling. The module is suited to developers, team leads, and operations staff who want a simple registry of ownership that can live alongside other Perl tooling. The project is open source on GitHub and welcomes contributions and bug reports.

EV::MariaDB is an asynchronous MariaDB/MySQL client for Perl that plugs into the EV event loop and uses the MariaDB Connector/C non‑blocking API to perform nonblocking connects, queries, and prepared statements. It is aimed at event‑driven applications that need high throughput and low latency, offering features like query pipelining, prepared statements with automatic buffer management, row‑by‑row streaming for large result sets, async transaction and connection control, BLOB/TEXT chunked upload, and graceful async close, with results delivered to callbacks in a simple (result, error) convention. It also supports Unicode when the connection charset is set to utf8 or utf8mb4 and can auto‑flag Perl strings for UTF‑8. Note that multi‑statement queries only return the first result to the caller while secondary result sets are consumed and any errors are reported via the connection error handler, and prepared statements should be closed to free resources.

EV::Pg is an asynchronous, non-blocking PostgreSQL client for Perl that plugs into the EV event loop and lets event-driven programs talk to Postgres without blocking. It provides a callback-driven API for parameterized queries, prepared statements, pipeline mode, single-row and chunked-row streaming, COPY IN/OUT, LISTEN/NOTIFY, async cancel, structured error fields, and protocol tracing, plus utility helpers for escaping and connection metadata. The module is aimed at developers building high-throughput or low-latency EV-based applications that need direct libpq async behavior and fine-grained control over send buffers and pipeline sync points. It requires libpq >= 14 and EV, with a few advanced features needing libpq >= 17, and includes performance-oriented features that make it a practical alternative to synchronous clients when non-blocking database I/O is important.

Data::HashMap is a family of C-backed, type-specialized hash maps for Perl that trade some of Perl's dynamic generality for much higher speed and lower memory usage. Each variant is tuned to a specific key/value combination (various int sizes, strings, or Perl SV* values) and exposes a keyword API that bypasses Perl method dispatch for maximum performance while still offering a method-call interface for convenience. The maps provide the usual put/get/exists/remove operations plus integer counters, compare-and-swap, bulk operations, optional LRU eviction, map-wide or per-key TTL expiry, and get-or-set semantics, making them well suited for caches, counters, and high-throughput lookup workloads. Benchmarks and memory figures in the documentation show substantial throughput and space advantages over plain Perl hashes. A few practical caveats are noted by the author: 64-bit variants require a 64-bit Perl, two sentinel integer values are reserved and rejected, get_direct returns a read-only, zero-copy view that must not be retained across mutations, and freeze/thaw produce native-endian blobs. If you need compact, high-performance maps and can accept type specialization and these constraints, Data::HashMap is a strong option.

Lingua::ZHO::Word2Num is a small Perl module that converts Chinese number words into numeric values, providing a single easy-to-use w2n function that accepts UTF-8 encoded text and returns the corresponding whole number from 0 up to 999,999,999,999 or undef when it cannot parse the input. It is useful when you need to extract or normalize numeric values written in Chinese for storage or computation, and it can be called directly as Lingua::ZHO::Word2Num::w2n or imported into your script.

Lingua::ZHO::Numbers converts numeric values into their Chinese word forms, letting you turn integers and decimals into readable Chinese using either object methods or a simple function call. It supports five output styles labeled traditional, simplified, big5, gb and pinyin so you can get either Chinese characters or romanized output, and you can switch the encoding with the charset method. The module follows the familiar Lingua::EN::Number interface with new, parse and get_string methods and also exports a number_to_zh function for quick use. It handles numbers from 0 up to, but not including, one trillion and emits Unicode character output for the character-based styles on modern Perl.

Lingua::Word2Num is a lightweight Perl wrapper that converts spelled-out numbers in many languages into numeric values. It offers both an object-oriented and a procedural interface so you can call cardinal(lang_code, text) to get a number or undef when conversion is not possible. The module delegates actual parsing to language-specific Lingua::XXX::Word2Num packages, so you must install the relevant language module and provide UTF-8 input. It supports a broad set of languages such as English, French, German, Spanish, Russian, Chinese, Japanese, Italian, Polish, Dutch and Czech and lets you query available languages with known_langs. Use it when you need to turn human-written number words from multilingual text into numeric data without building separate parsers for each language.

Lingua::SWE::Word2Num converts Swedish words that spell out integers into numeric values, handling whole numbers from 0 up to 999,999,999,999. It expects UTF-8 encoded input and exposes a simple API where w2n($string) returns the numeric value or undef if the text cannot be parsed, and an sv_numerals parser object is available for internal or advanced use. Use this module when you need to extract numeric data from Swedish text such as documents, transcripts, or user input; it concentrates on whole numbers within the stated range and will not convert unsupported or unrecognized forms.

Lingua::SWE::Num2Word is a small Perl module that converts whole numbers into their Swedish cardinal-word forms, handling integers from 0 up to 999,999,999 and returning UTF-8 encoded text. Its primary function, num2sv_cardinal, accepts a number and returns the Swedish words or undef if the input is out of the supported range or cannot be converted. Use this module when you need readable Swedish number text in scripts for invoices, reports, voice prompts, or localization tasks. It is lightweight, easy to call from Perl code, and maintained by Vitor Serra Mori.

Lingua::SPA::Word2Num is a small Perl module that converts Spanish number words into integer values, for example turning "veintisiete" into 27, and it handles whole numbers from 0 up to 999,999,999,999. It expects UTF-8 input and provides a simple function w2n that returns the numeric value or undef if the text cannot be recognized, with an internal parser available as spa_numerals for advanced use. The module is useful when you need to extract or normalize written Spanish numerals into machine-readable numbers, but it focuses on whole numbers and will not parse formats outside its supported range.

Lingua::SPA::Numeros converts numbers into Spanish words, handling cardinals, ordinals and real numbers and even very large integers by keeping values as text so it can work up to about 1e127. You can customize output with options for decimal and thousands separators, accented or HTML-entity output, uppercase, grammatical gender (masculine, feminine or neutral), a choice of rendering "1000" as "un mil" or "mil", and a format string to control how fractional parts are expressed. The module provides simple methods like cardinal, ordinal and real plus accessor methods to tweak settings, making it handy for generating human-readable amounts in documents, invoices, forms or speech output in Spanish.

Lingua::RUS::Word2Num is a small Perl utility that converts Russian words for whole numbers into numeric values, handling integers from 0 up to 999,999,999. It expects UTF-8 encoded input and exposes a simple w2n function that returns the numeric value or undef when the text cannot be parsed. The module also provides an internal parser constructor for advanced use but is mainly useful for scripts that need to extract or normalize numeric amounts from Russian text.

Lingua::RUS::Number converts numeric amounts into Russian money phrases so you can print roubles and kopecks in words. Its main routine rur_in_words accepts a number and returns a UTF-8 string with the amount spelled out in Russian, for example 1.01 becomes "odin rubl' odna kopejka" and 2.22 becomes "dwa rublja dwadcat' dwe kopejki". The module is small and focused, making it handy for invoices, checks, reports, or other output where amounts must appear in words. Tests use Test::More::UTF8 to handle encoding issues and the package is maintained by Richard C. Jelinek with initial coding by Vladislav A. Safronov.

Lingua::POR::Words2Nums is a small Perl utility that turns Portuguese number words into their numeric equivalents, for example word2num("cinco") returns 5. It handles a wide range of values up to 999,999,999,999,999,999 so it is useful for text processing, data extraction, or simple natural language interfaces that need to pull numbers out of Portuguese text. The module focuses on common, unpunctuated forms and does not cover every possible spelling or formatting variant, for example some comma-separated phrasing and alternative billion spellings are not supported. If you need a straightforward way to convert ordinary Portuguese number words into integers in Perl, this module provides a compact ready-made solution.

Lingua::POR::Nums2Words is a compact Perl module that converts integers into their written Portuguese equivalents. It exposes a single function, num2word, which you call with a number or a list of numbers and it returns the corresponding Portuguese words for values from 0 up to 999,999,999,999,999. The module does not support negative numbers. It is handy for generating human readable output in invoices, reports, voice prompts, accessibility text, or any Perl application that needs numbers spelled out in Portuguese and integrates easily into existing code.

Lingua::POL::Word2Num is a Perl module that converts Polish number words into integers, handling whole numbers from 0 up to 999,999,999. It expects UTF-8 encoded input and exposes a simple w2n function that returns the numeric value or undef when the text cannot be parsed, plus a pol_numerals constructor for creating a parser object. This module is useful when you need to parse or normalize Polish textual numbers in user input, scraped text, transcripts, or data cleaning tasks.

Lingua::POL::Numbers is a lightweight Perl module that converts numeric values into spelled-out Polish words, offering a simple object interface with new, parse for general numbers, and currency to render amounts as zloty and grosz. It is useful when you need human-readable Polish numbers for invoices, checks, reports, accessibility or localization in Perl applications. The distribution is a PetaMem release in the iso-639-3 namespace and keeps most helper routines internal, so usage is straightforward and focused on the two main functions. The author lists no known bugs at release time, but as with any library users should test edge cases relevant to their data.

Lingua::Num2Word is a lightweight wrapper that converts numbers into written words by delegating the work to language-specific Lingua::XXX::Num2Word modules. It offers both an object interface and procedural functions such as cardinal to perform conversions, known_langs and langs to list available and ISO language codes, and get_interval to find the numeric range a particular backend supports. Output is encoded as UTF-8 and the actual languages you can use depend on which language modules are installed, with common bindings available for English, French, German, Czech, Japanese, Russian and others. Use this module when you want a single, consistent API to produce number names across multiple languages while relying on existing CPAN language modules for the specific rules.

Lingua::NOR::Word2Num converts Norwegian number words into integer values so you can turn text like "fire hundre" into 400. It exposes a simple w2n function that returns the numeric value or undef when the input cannot be parsed. The module handles whole numbers from 0 up to 999,999,999 and expects UTF-8 input. It is a lightweight utility for scripts and applications that need to normalize Norwegian textual numbers into numeric form, and it also provides an internal parser object for more advanced use.

Lingua::NOR::Num2Word is a compact Perl module that converts whole integers into Norwegian words and produces UTF-8 encoded text. It covers numbers from 0 up to 999,999,999 and offers a simple object interface with new to get a singleton instance and num2no_cardinal to perform the conversion. The module is handy for producing human readable numbers in Norwegian for things like invoices, checks, reports, and user interfaces. It was inspired by Lingua::CS::Num2Word and is maintained by PetaMem. If a value is out of range or cannot be converted the method will not return a string. The module is free software distributed under the same terms as Perl.

Lingua::NLD::Word2Num is a small Perl module that converts Dutch number words into integers, turning strings like "dertien" into 13 and handling whole numbers from 0 up to 999,999,999,999. It exposes a simple w2n function that returns a numeric value or undef when the input cannot be parsed, and it requires UTF-8 encoded input. The module is useful for parsing or normalizing Dutch text in forms, logs, or natural language interfaces where numeric words need to be converted back to machine-readable numbers. It focuses on whole numbers only and does not handle fractions or nonstandard formats.

Lingua::NLD::Num2Word is a compact Perl utility that converts whole numbers into their written Dutch form, returning a UTF-8 encoded string for integers in the range 0 to 999,999,999 and undef for values outside that range. It exposes the num2nld_cardinal function which can be imported for straightforward use in scripts and web apps, making it handy for producing human-readable amounts in invoices, reports, checks, speech prompts or localization tasks. Note that the POD contains a stray mention of German, but the module name and examples indicate it is intended for Dutch.

Lingua::JPN::Word2Num is a small Perl utility that turns Japanese number words into numeric values, for example converting strings like "sen ni hyaku san ju yon" into an integer. It handles whole numbers from zero up to 999,999,999,999 and returns the numeric value or undef when it cannot parse the input. The module exposes a single easy-to-use function w2n and provides a parser object for internal use. Input must be UTF-8 encoded, so it is handy for scripts, form processing, or basic natural language tasks that need to normalize Japanese numeric expressions into machine-friendly numbers.

Lingua::JPN::Number converts integer values into their Japanese cardinal pronunciations written in romaji, returning the spoken components so you can see how a number is actually pronounced in Japanese. It handles basic digits and place names like ju, hyaku, sen and man, applies the common irregular pronunciations such as sanbyaku, roppyaku, happyaku, sanzen and hassen, and respects Japanese grouping by four digits rather than by thousands. The module is handy for language tools, quizzes, or any script that needs a readable spoken form of numbers in Japanese. The author notes they are still learning Japanese and welcomes bug reports, and plans additional modules to handle the various counter systems used for people, long objects and other categories.