CPANscan

CXC::Data::Visitor provides a visit() routine that walks nested Perl hashes and arrays depth first and calls a user callback for each element, making it easy to inspect or modify complex data structures. The module gives you fine control over what is visited by letting you restrict callbacks to containers, arrays, hashes, leaves, or the root, and it supplies metadata for each visit that includes the full path and ancestor containers so you always know where you are. Your callback returns exported RESULT_* constants to steer traversal, for example to continue, stop descent into a container, revisit an element or its contents, restart the traversal at the root, or abort, and you can also customize key and index ordering and how cycles are handled. Objects are treated as terminal values and containers reachable from multiple parents are visited once per parent, cycle handling defaults to throwing an exception but can be changed or delegated to a coderef, and recent releases stabilized the API with 0.12 promoted to production and earlier 0.11 adding the ability to explicitly visit the root and a RESULT_REVISIT_ROOT directive to restart traversal.

Ham::DXCC::Lookup is a small, focused Perl module that maps amateur radio callsigns to their DXCC entity, offering a simple lookup_dxcc function that accepts a callsign like G4ABC and returns a hash reference containing DXCC information such as the dxcc_name, and it can also be run from the command line for quick checks. It performs basic callsign validation using a common callsign pattern and is best suited as a lightweight helper for logging, contesting, or scripts that need to translate callsigns to DXCC entities rather than as a full-featured database. The module is provided as-is without warranty and carries specific licensing terms: personal single-user use is GPL2 while other users must obtain a license from the author.

Object::Pad gives you a clean, modern way to write class and role definitions in Perl by letting instance fields appear as lexical variables that methods can use directly, making code easier to read and reason about than raw blessed hashes. It supplies an automatic constructor with named-parameter support via field :param annotations, convenient field attributes like :reader, :writer and :accessor, and lifecycle phasers such as BUILD and ADJUST for initialization logic. Roles, lexical methods and private methods are supported, various representation options are provided for compatibility with existing non-Object::Pad bases, and the module intentionally mirrors and prototypes the core Perl "class" feature so you can write forward-compatible code or use Feature::Compat::Class for broader portability. Some newer capabilities remain experimental and emit warnings until stabilized, but the core system is mature and actively maintained. Recent releases improved role behavior by allowing anonymous and captured method closures inside roles to be invoked on applied class instances and updated the minimum Perl requirement to 5.22, which simplifies the implementation while keeping the API modern and practical. If you are building new object-oriented Perl code or migrating legacy classes toward a clearer, lexical-field style, Object::Pad is likely to be relevant and helpful.

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.

Regexp::Assemble lets you feed many Perl regular expressions into an assembler object and emit one compact, compiled regular expression that matches anything any of the originals would match. This is useful when you have hundreds or thousands of patterns and want to test a target string with a single, optimized regex instead of looping over a list. The module performs reductions, merges character classes, supports anchors, flags, lookahead and pretty printing, can read patterns from files and can optionally track which original pattern produced a match. There are caveats though, the default lexer is simple and can mis-tokenize deeply nested parenthesis constructs, tracking on older Perls requires use re 'eval' and carries security concerns, and enabling tracking prevents reductions so the assembled pattern may be bulkier. Also be aware that very large alternations are still costly in Perl in some versions so a trie-based approach may sometimes be preferable. Overall it is a mature, configurable tool for consolidating many regexes into a single matcher when you need to simplify pattern management and improve matching throughput.

DB::Handy is a self-contained, pure-Perl relational database engine that gives you a DBI-like API for creating databases and tables, running SQL queries, and using prepared statements without any external server or non-core dependencies. It stores data in fixed-size binary flat files and supports a large subset of SQL including joins, subqueries, set operations, GROUP BY, aggregates, ORDER BY, LIMIT/OFFSET and many common functions while providing convenient fetch and select helpers familiar to DBI users. The module is ideal for small to medium embedded or portable workloads where ease of deployment and cross-platform compatibility matter, and it offers simple file locking and on-disk indexes to speed equality and range lookups. It is not a full RDBMS so it has intentional limitations such as no transactional support, no BLOB/CLOB types, VARCHAR values being stored in a fixed 255-byte field, no composite indexes, no enforced foreign keys and no SQL window functions, so you should choose something like SQLite if you need those features. The current 1.07 release mainly tightens compatibility and packaging by declaring the minimum Perl version and improving documentation and test coverage.

JSON::Structure provides Perl tools for validating both JSON Structure schemas and JSON data against those schemas according to the JSON Structure Core specification. It offers SchemaValidator and InstanceValidator classes along with simple helpers like validate_schema and validate_instance so you can check that a schema is well formed and then validate decoded JSON instances, receiving a result object with is_valid and error details for easy reporting. JSON Structure is a type-oriented schema language meant to describe and map JSON data to programming language types, so this module is useful when you need precise, reusable type-driven validation of JSON in Perl and it integrates easily with common JSON libraries such as JSON::MaybeXS.

Alt::Digest::MD5::OpenSSL is a drop-in alternative to Digest::MD5 that keeps the familiar MD5 API while delegating the actual hashing to the system OpenSSL library instead of bundled C code. It is aimed at users who prefer to rely on an audited, centrally maintained crypto implementation or want to avoid shipping their own MD5 C sources, and it should work as a direct replacement in code that already uses Digest::MD5. Recent updates added a proper LICENSE file and package metadata and strengthened the test suite and OpenSSL diagnostics to improve reliability and packaging.

MetaCPAN::Pod::HTML converts Perl POD into modern HTML5 with better results than the default Pod::Simple::XHTML output. It is the MetaCPAN subclass that adds reliable header anchors and link overrides, inserts errata into rendered pages, offers more accurate link targets and hints for syntax highlighting, and sensibly strips indentation from verbatim blocks, with anchor generation enabled by default. The module is built to produce web-ready documentation for MetaCPAN but can be used anywhere you need robust POD-to-HTML conversion. A recent fix ensures section links are encoded correctly for characters outside ISO-8859-1 so anchors do not break for non-Latin headings.

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.

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.