CPANscan

Loo is a compact, XS-based Perl data inspector and code deparser that produces Data::Dumper-style output with optional ANSI colour highlighting. It can serialize complex Perl structures and can also deparse code references back to readable Perl source by walking the op tree in C, and it offers both simple functional shortcuts (Dump, cDump, ncDump, dDump) and an OO interface for fine-grained control. The OO interface exposes familiar Data::Dumper-style options such as indentation, variable naming, sorting, max depth and purity flags, plus themable colour configuration and built-in palettes, and there is a utility to strip ANSI escapes when you need plain text. Colouring is auto-detected from environment and terminal state but can be forced on or off, and the distribution shown here is the initial public release.

Test::Expander is a lightweight helper for Test2::V1 that removes repetitive test boilerplate by automatically deriving and exporting the class and method under test from your test file path and name, providing ready-made variables like $CLASS, $METHOD and $METHOD_REF. It also includes a built-in table driven testing helper that reads test cases from a .tdt file or the DATA section, can create temporary dirs and files, adjust @INC via a -lib option, override builtins in the target namespace, and load a clean, cascading environment from .env files so tests are easier to write and refactor. The module re-exports familiar Test::More and Test::Exception helpers to ease migration to Test2::V1, supports selective subtest execution and a bail-on-failure mode, and prints diagnostics about the exported state. Use it as the first module in your test file to avoid ordering issues, be aware that -lib entries are string-evaled so quoting can be tricky, and note that $TEST_FILE is not available in one-line (-e) tests.

Anonymous::Object is a small utility for quickly generating ad hoc, nameless Perl objects from ordinary data structures so you can treat hashes and arrays as lightweight objects without writing a full class. It can turn flat or nested hashes and arrays into objects, generate common accessor helpers like get, set, clear and predicate, apply optional type checks using Types::Standard or a custom type map, and populate defaults or a custom new method before building the object. The module is useful for one-off data containers and simple DTOs where you want method-style access without boilerplate code. A recent enhancement added hash_to_object_context to preserve lexical context when hash values are subroutines, letting closures become usable object methods.

Thrift::XS is a drop-in XS replacement for Perl's Thrift BinaryProtocol and MemoryBuffer that speeds up Thrift encoding and decoding, with an equivalent CompactProtocol implementation available. Swap Thrift::XS::BinaryProtocol or Thrift::XS::CompactProtocol and Thrift::XS::MemoryBuffer into existing Thrift clients to get substantial performance gains across message framing, container headers and primitive reads and writes, with some operations reporting order-of-magnitude improvements. For best results pair it with a high-performance socket layer because standard transports like BufferedTransport, FramedTransport or HttpClient can limit the benefit and HttpClient in particular makes many tiny system calls. The module focuses on protocol and buffer performance, is Apache 2.0 licensed, and was authored by Andy Grundman.

Travel::Routing::DE::DBRIS is a Perl interface for querying Deutsche Bahn's bahn.de itinerary service and returning rich itinerary objects you can iterate in code. You give it origin and destination Location objects from Travel::Status::DE::DBRIS and it fetches connections made up of Connection and Segment objects that expose departure and arrival times, transfer and walking legs, and other segment details. The constructor accepts options for stopovers, departure datetime, language, modes of transit, passenger details for pricing, HTTP caching and user agent configuration so you can tune queries for your use case. The module is actively developed and marked as work in progress but recent releases improve robustness by handling DST-related backend timestamp quirks, showing arrival dates for overnight trips, and making transit mode identifiers case-insensitive.

Travel::Status::DE::DBRIS is an unofficial Perl client for Deutsche Bahn's bahn.de departure monitor and train info APIs that lets developers fetch station departure boards, search stations by name or location, request trip details and, where available, carriage formation data. It works synchronously or asynchronously via promises and Mojo::UserAgent and returns tidy objects representing stations, departures and journeys so you can print schedules, delays, routes or coach layouts in your own tools. The module supports caching of successful and failed requests, filtering by transport mode, loading prepared JSON for testing, and various timeout and user agent options to cope with the real backend. Note that the project is still a work in progress and the author warns that Deutsche Bahn’s WAF can throttle or block aggressive request patterns, so the module includes mitigations such as randomized headers and configurable failure caching, and the default timeout was recently raised to 20 seconds; a small API change in 0.25 removed a couple of formation accessors because that data is no longer provided upstream.

Travel::Status::DE::VRR is an unofficial Perl client for the VRR public-transport departure monitor that makes it easy to fetch live departure boards and related trip information from EFA-based backends. You create an object with the stop or place you care about and the module returns rich departure objects that include scheduled and realtime times, platform, line and destination and often occupancy and route details, so it is useful for building small scripts, dashboards or command line tools. The module is a thin, well maintained wrapper around Travel::Status::DE::EFA and supports features like stop lookup and trip details, synchronous and promise-based constructors, configurable result counts and robust handling of real‑world quirks such as DST transition timestamp problems. It depends on common Perl modules like DateTime and LWP::UserAgent and is distributed under the same license as Perl.

Mo::utils::UDC is a tiny utility for Mo-based data objects that validates Universal Decimal Classification (UDC) strings. It provides a single function, check_udc($self, $key), which looks up the value named by $key in your object or hash and ensures it is a syntactically valid UDC code while allowing undefined or missing values. Validation is done via Business::UDC and failures are reported through Error::Pure, so successful checks simply return undef and invalid values raise a clear error. This module is useful when you need a lightweight, drop-in validator for UDC fields in applications using Mo, and version 0.01 is the initial release.

Business::ISBN::Data is a data pack used by Business::ISBN to provide publisher and group range information for validating and parsing ISBNs. It contains the ISBN Agency's RangeMessage.xml data bundled with the module and is normally auto-loaded by Business::ISBN, so you rarely need to use it directly. You must use Business::ISBN 3.005 or later because the data structure changed to fix ISBN‑13 prefixes. If you need newer or alternate range data you can point the module at another RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN, and if no external file is available it falls back to the built-in data or to a RangeMessage.xml in the current directory. The distribution includes a script to regenerate the default data from a fresh RangeMessage.xml and the source and updates live on GitHub for contributions.

Clone is a small, fast XS-backed Perl module for making deep, recursive copies of scalars, arrays, hashes and references, including blessed objects, tied variables, weakened references and circular structures so you get an independent replica of complex data. It preserves tie behavior and weakened refs, avoids infinite loops on circular graphs, and documents cases where cloning shares internals such as code references or the underlying file descriptor of filehandles. Because it is implemented in C it is optimized for speed in shallow to medium-depth structures, but cloning very large or extremely deep data uses more memory and has a recursion depth limit, so for serialization-heavy or extreme-depth cases Storable::dclone may be worth benchmarking. Recent maintenance releases brought performance optimizations and multiple bug and test fixes, quieter DBI-related tests, packaging tweaks for macOS, and an AI policy document for the project.

Lingua::JA::Moji is a practical Perl toolkit for converting between many written forms of Japanese, offering robust kana<->romaji conversion with multiple romanization styles, validators and normalization helpers, plus utilities for hiragana/katakana switching, halfwidth/fullwidth ASCII and kana, circled and bracketed forms, hentaigana support, morse and braille mappings, and conversions for old/new kanji variants. It assumes Unicode (UTF-8) strings and loads conversion data on demand to keep memory use modest. The module includes convenience helpers such as character classes for regexes and functions to join or split dakuten marks, and it exposes experimental cyrillization and hangul mappings while noting those areas are less mature. It does not attempt lexical kanji-to-kana or kana-to-kanji reading conversion. In the recent 0.61 release a bug in kunrei romanization was fixed and a "wikipedia" option was added to adjust macroned ii handling.

Lingua::IND::Nums2Words is a deprecated compatibility wrapper that turns numbers into Indonesian words by delegating all work to Lingua::IND::Num2Word. It keeps the old object-style API, providing new() and parse() for legacy code but emits a deprecation warning and users are encouraged to use Lingua::IND::Num2Word::num2ind_cardinal instead. The module itself adds no new features and exists only to avoid breaking older scripts. Recent maintenance reorganized legacy Num2Word modules under a canonical namespace and added basic capabilities introspection plus an ordinal conversion stub in the underlying infrastructure.

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::KOR::Word2Num is a Perl module that converts Korean number words in the Sino-Korean system into whole integers, supporting values from 0 to 999,999,999,999. It expects UTF-8 input and provides a simple w2n function that returns the numeric value or undef when conversion fails. The module handles native Korean text and simple romanized forms and offers an internal kor_numerals parser for advanced use. Use it when you need to extract or normalize numeric values from Korean text in scripts, data processing, or basic NLP workflows.

Email::Abuse::Investigator is a Perl module that turns a raw spam or phishing message into actionable intelligence by parsing headers and bodies to identify the likely originating IPv4 address, extract all HTTP/HTTPS links and contact domains, resolve hostnames to IPs, and query RDAP/WHOIS to find network owners and abuse contacts. It collates MX and NS data, parses DKIM and list-unsubscribe headers, flags recently registered or lookalike domains, and produces a weighted risk assessment plus both an analyst-friendly full report and a compact, send-ready abuse report with deduplicated recipient addresses. The analyser is configurable with timeouts and trusted-relay exclusions and caches results per parsed message to avoid repeated lookups. It is designed to help security teams and abuse desks quickly determine who to contact and what evidence to include when reporting malicious mail. Note that the module extracts only IPv4 addresses, is not thread-safe, and WHOIS timeouts may be unreliable on some platforms such as Windows.

Task::Lingua::Word2Num is a metapackage that makes it simple to add word-to-number conversion support across languages by installing the Lingua::Word2Num dispatcher and all PetaMem-maintained, language-specific Lingua::*::Word2Num modules. It does not implement conversion logic itself but gathers the needed modules for parsing numbers written in words into numeric values, so it is useful when you want broad, multi-language number normalization without pulling in each converter individually. The distribution is maintained by PetaMem and continues work started by earlier contributors.

Task::Lingua::PetaMem is a CPAN task bundle that installs PetaMem's Lingua number conversion toolset, bringing together Task::Lingua::Num2Word and Task::Lingua::Word2Num so you can convert numbers to words and words back to numbers in 33 languages. It covers many European and Asian languages plus Swahili and accepts both ISO 639-1 and ISO 639-3 language codes, so you can call the supplied functions to produce output like "zweiundvierzig" from 42 or to parse "quarante-deux" back to 42. The package itself mainly orchestrates installation of the language-specific converters rather than adding new APIs. Install it with your CPAN client to quickly add multilingual numeric text handling for localization, data cleaning, NLP, or voice applications.

Task::Lingua::Num2Word is a convenience meta-package that installs PetaMem's Lingua::Num2Word dispatcher together with all of the language-specific number-to-word modules they maintain, including modules with names like Numbers, Number, Nums2Words, and Numeros. It does not add new conversion code itself but saves you the work of finding and installing each language module individually, so you can quickly get broad multilingual number-to-word support in Perl with a single install. The collection is maintained by PetaMem.

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 is a deprecated compatibility shim that turns numbers into Chinese words by forwarding all work to the newer Lingua::ZHO::Num2Word module. It preserves the old API and charset selection so legacy code that used constructions like use Lingua::ZHO::Numbers 'traditional' or 'big5' will still run, but the constructor emits a deprecation warning and methods such as charset, parse and get_string simply delegate to Lingua::ZHO::Num2Word. Use this module only to maintain backward compatibility; for new code you should call Lingua::ZHO::Num2Word directly (for example num2zho_cardinal for cardinal numbers).

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::VIE::Word2Num converts Vietnamese numerals written as words into integers in the range 0 to 999,999,999. It exposes a simple w2n function that accepts a UTF-8 string and returns the numeric value or undef if the text cannot be parsed. The module is aimed at developers who need to turn user-entered Vietnamese numbers, form fields, or transcribed speech into machine-readable values without writing a custom parser, and it also provides an internal parser object for more advanced use.

Lingua::VIE::Num2Word is a small Perl module that turns integer numbers into their written Vietnamese form, handling whole numbers from 0 up to 999,999,999 and returning the result as UTF-8 encoded text. You call the provided function num2vie_cardinal either fully qualified or by importing it, pass the number you want converted, and get a string back or undef if the value is out of range or not supported. It is useful for localization, generating human readable amounts, accessibility or voice prompts where Vietnamese number words are needed, and is focused on cardinal integers rather than decimals or negative numbers.

Lingua::UKR::Word2Num converts Ukrainian number words into integers. It parses whole number spellings from 0 up to 999,999,999 and returns the numeric value or undef when the input cannot be interpreted. The module exposes a simple w2n function that accepts a UTF-8 encoded string and returns the corresponding number, and it also provides an internal parser object via uk_numerals for more advanced use. Use this module when you need to extract or normalize numeric values written in Ukrainian text. Note that it handles only whole numbers in the documented range and requires UTF-8 input.

Lingua::UKR::Num2Word is a compact Perl module that turns whole numbers into their Ukrainian cardinal word forms. You call its main function, num2ukr_cardinal, with an integer and it returns a string containing the number spelled out in Ukrainian for values from 0 to 999,999,999, otherwise returning undef if the input is unsupported. The function is available for export on demand and is useful for producing human readable amounts, labels, or prompts in Ukrainian without having to implement language rules yourself.

Lingua::SWE::Word2Num converts Swedish number words into numeric values, handling whole numbers from 0 up to 999 999 999 999 and expecting UTF-8 input. Its public API is simple: call w2n with a Swedish number phrase and you get back the numeric value or undef if the text cannot be parsed, and a parser object is available for more advanced usage. The module is handy for text processing, form parsing, chatbots, and other situations where written Swedish numerals should be normalized to digits. A recent release added ordinal support for Swedish and moved the project toward a unified, multi-language infrastructure to make capability discovery and cross-language use easier.

Lingua::SWE::Num2Word converts integers into Swedish words, providing both cardinal and ordinal forms for numbers from 0 up to 999,999,999. It exposes two functions, num2sv_cardinal and num2sv_ordinal, that return the Swedish text encoded in UTF-8 or undef when a number is out of range or cannot be converted. The ordinal routine knows irregular Swedish ordinals such as forsta, andra and tredje and applies the correct endings for regular cases. This lightweight module is easy to call from Perl scripts and is useful whenever you need human‑readable Swedish numbers in text, reports or prompts, and it is released under permissive open source licenses.

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 is a deprecated compatibility wrapper that converts numbers into Spanish words by delegating to Lingua::SPA::Num2Word; it preserves the old object API (new and parse) and emits a deprecation warning, but new code should call num2spa_cardinal from Lingua::SPA::Num2Word instead. The module exists to keep legacy code working while the real conversion logic lives in the newer Num2Word package, which in recent releases was reorganized into a canonical namespace and gained broader capabilities such as ordinal support for many languages and introspection features.

Lingua::RUS::Word2Num is a small utility that turns Russian number words into numeric values, accepting UTF-8 text and handling whole numbers from 0 up to 999,999,999. You call its w2n function with a Russian phrase and it returns the corresponding number or undef when the phrase cannot be parsed. It is focused on parsing ordinary cardinal numerals and includes an internal parser object for advanced use. The wider distribution has recently expanded multilingual support and added ordinal handling and introspection features across related modules, while this package remains the concise Russian-language converter.