CPANscan

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.

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.

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

Lingua::ITA::Word2Num is a small Perl library that converts Italian words for whole numbers into numeric values, handling numbers from 0 up to 999,999,999,999. It exposes a simple w2n function that takes a UTF-8 encoded Italian number string like "trecentoquindici" and returns the corresponding integer or undef if the text cannot be parsed. The module is useful for text processing, data cleanup, and simple NLP tasks where spelled-out Italian numerals need to be normalized to digits, and it provides an internal parser object for more advanced use.

Lingua::ITA::Numbers converts numeric values into their Italian word equivalents and can be used either as a simple procedural function number_to_it or as an object with methods like get_string and set_number. It supports options to control minimal decimal places, two styles for fractional parts (decmode "normal" to say "virgola ..." or "fract" to say "e ... centesimi"), and a name option to append singular or plural currency labels. Objects are implemented as two-face scalars so they behave as numbers in arithmetic and as Italian strings when printed, which makes them handy for reports, invoices, localization, or text-to-speech prep. The module is straightforward to use but the author notes that decimal handling is not fully correct and there is no validation of option values.

Lingua::IND::Nums2Words converts numeric values into Indonesian words, producing either a full voiced form or a simple digit-by-digit form via nums2words and nums2words_simple. It handles integers and real numbers including scientific notation up to the order of hundreds of trillions and preserves formatting such as trailing zeros so that "1.00" is pronounced with its zeros. Numbers greater than 10**15 cause the function to return 0. This module is handy for generating Indonesian-language number text for reports, invoices, or speech output and is maintained by PetaMem with original author Steven Haryanto.

Lingua::FRA::Numbers converts numeric values into their French word equivalents, producing both cardinal and ordinal forms in a straightforward, programmer-friendly way. It offers both a procedural interface with exportable functions number_to_fr and ordinate_to_fr and an object oriented API with new, parse, get_string and get_ordinate methods, so you can call it directly or wrap it in objects. Decimal conversion is supported but marked experimental. For very large values you can pass Math::BigInt objects and the module aims to handle numbers up to about 1e75 while being reliably correct up to roughly 1e51 due to limits in documented French naming beyond that range. The module reports invalid formats and numbers that are too large and is compatible in spirit with similar English-number modules, making it a practical choice when you need readable French number names in scripts or applications.

Lingua::EUS::Word2Num converts Basque (Euskara) number words into numeric integers. It accepts UTF-8 text and handles whole numbers from 0 up to 999,999,999,999. The module exposes a simple w2n function that returns the numeric value or undef when the input cannot be parsed. An internal parser object is also available for advanced use. This is a practical tool for applications that need to interpret Basque numerals in natural language input or text processing.

Lingua::EUS::Numbers is a Perl module that turns integers into Basque (Euskara) words, offering cardinal2alpha and ordinal2alpha for converting numbers to cardinal and ordinal forms and optionally exporting the %num2alpha map for custom dialect tweaks. It handles nonnegative integers up to 999,999,999,999 and returns undef for undefined, non-integer, or out of range inputs. The module uses standardized Euskara Batua spelling, which may differ from regional variants, and reflects Basque's vigesimal counting tendencies, making it useful for localization, natural language output, or any application that needs Basque number names.

Lingua::ENG::Numbers converts numeric values into readable English words. You create an instance (optionally with a number) or call parse to load a value and then call get_string to receive a human-friendly English rendering. It handles integers and decimals, accepts common group and decimal delimiters like commas and periods, and lets you tweak output pieces such as group and number delimiters and the decimal word used. The module currently supports American-style English only and is designed for straightforward numeric formats rather than complex localized inputs. It handles numbers up to 10^66 and is handy for generating number words for reports, checks, or user interfaces.

Lingua::ENG::Inflect is a Perl module for handling English inflection and basic natural-language formatting, letting you convert singular words to their correct plurals for nouns, verbs and some adjectives, pick the right indefinite article ("a" or "an") based on pronunciation and initialisms, turn numbers into ordinals or into English words, and build nicely punctuated word lists. It provides convenience helpers so you can emit counts together with correctly inflected nouns, compare words irrespective of number, form present participles, and interpolate inflections directly inside strings with inflect, and it supports a "classical" mode to prefer Latin/Greek plurals when desired. The module is extensible at runtime via def_noun, def_verb, def_adj, def_a and def_an and will load per-user or system-wide .inflectrc files so you can customize exceptions and overrides. NUMWORDS supports grouping, custom renderings for zero and one, decimal translation and ordinal input but is limited to conventional large-number names and accepts grouping values 1 to 3. The implementation favors standard British spelling while tolerating common American variants and does not aim to cover slang or niche dialects, and note that .inflectrc files are executed as Perl code so malformed customizations can cause fatal errors.