CPANscan

Geo::BUFR is a Perl module for reading, decoding, encoding and manipulating WMO BUFR binary meteorological messages. It supports the BUFRDC and ecCodes table formats and expects the corresponding BUFR table files to be installed separately. The module provides an object oriented API to open BUFR files or buffers, iterate observations, load B, C and D tables, filter messages, pretty print sections and bitmaps, reencode or construct messages, join subsets from multiple sources and perform format checks. Core bitstream handling is implemented in C for performance and several ready made command line utilities are included so many users will only need those tools. The module offers configurable strict checking and options to skip data decoding when only metadata is required. A few advanced C table operators are not implemented or tested due to lack of example messages, so you may encounter edge cases with unusual BUFR files.

Horus is an ultra-fast XS UUID/GUID generator for Perl that implements all RFC 9562 versions (v1–v8) plus NIL and MAX, and offers ten output formats including hyphenated string, hex, braces, URN, base64, base32, Crockford base32 and raw binary. It is a pure XS module with no external C library dependencies and is optimized for high throughput and low Perl/C boundary overhead, with bulk generation, an object interface, and support for deterministic namespace UUIDs (v3 and v5), time and monotonic variants (v1, v6, v7), random v4, and custom v8 payloads. The module also includes utilities for validation, parsing, conversion, comparison and extracting timestamps, making it a good choice when you need fast, flexible UUID generation for high‑performance services, databases or distributed systems.

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::NLD::Numbers is a deprecated compatibility wrapper that turns numbers into Dutch words by delegating the work to Lingua::NLD::Num2Word. It keeps the old object-style API with new() and parse() so legacy code continues to run, but those methods emit deprecation warnings. For new code you should use the Num2Word module and its num2nld_cardinal function instead.

Lingua::LAV::Word2Num converts Latvian number words into integer values, turning phrases like "divdesmit tris" into numeric form for use in data processing, form parsing, or simple NLP tasks. It exposes a single callable function, w2n, which returns a Perl number for valid inputs or undef when the input cannot be parsed. The module expects UTF-8 input and handles whole numbers in the range 0 to 999,999,999. A lav_numerals parser object is available internally. This is a focused utility for projects that need reliable, language-specific word-to-number conversion for Latvian text.

Lingua::LAV::Num2Word converts whole numbers into Latvian cardinal words, so you can display numbers as text in reports, invoices, forms, or simple localization tasks. It exposes a single conversion routine num2lav_cardinal that accepts integers from 0 up to 999999999 and returns the Latvian wording or undef when a number is out of range. The module handles Latvian declension and hundreds internally so you do not need to manage grammatical details yourself. It is lightweight, easy to call from your Perl code, maintained by Richard C. Jelinek and PetaMem, and is available under permissive Artistic 2.0 or BSD 2-Clause licensing.

Lingua::ISL::Word2Num converts Icelandic number words into integer values. It accepts UTF-8 Icelandic text for whole numbers in the range 0 to 999,999,999 and returns a Perl integer or undef if the input cannot be parsed. The module provides a simple w2n function for one-line conversions and an internal parser object available as isl_numerals for more advanced use. This is a practical tool for scripts and applications that need to extract, normalize, or process numeric information from Icelandic text.

Lingua::ISL::Num2Word converts whole numbers into their written Icelandic form, handling integers from 0 up to 999,999,999 and producing UTF-8 text suitable for display or printing. You call the exported function num2isl_cardinal with a number and receive an Icelandic word string or undef for out-of-range or unknown inputs. The module also includes a small internal helper for neuter number forms used with words like hundred and thousand. It is a lightweight, focused tool for generating human-readable Icelandic numbers in invoices, reports, or text generation tasks and is available under permissive open source licenses.

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.

Data::HashMap::Shared implements very fast, file-backed shared-memory hash maps for Linux running 64-bit Perl, letting multiple processes open the same mmap file and share data with minimal locking. It ships as a family of type-specialized variants (integer-to-integer, string-to-string, mixed types, etc.) so lookups, atomic increments and compare-and-swap operations are implemented with native, low-overhead storage for peak throughput. The module uses futex-based locks and a seqlock-style fast read path so reads are effectively lock-free when LRU and TTL are disabled, and it adds optional features like per-key TTLs, an LRU clock eviction policy that avoids write contention, an arena for string storage with small-string inline storage, sharded maps for parallel writes, cursor-safe iteration and a keyword API for the absolute fastest call path. It also includes crash-detection and recovery of stale writers via PID tracking though cross-container PID namespaces are not supported, and it exposes rich diagnostics and file management tools. The recent 0.02 release notably expands the API with atomic swap/CAS, queue-style pop/shift/drain, batch set/get, TTL/LRU controls and stats, introduces lock-free clock/second-chance LRU reads, inline small-string nodes, SSE2 probe acceleration, a faster monotonic clock for TTLs and C-level sharding for parallelism, making it a strong choice when you need extremely fast, concurrent, cross-process shared hash tables on Linux.

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::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::TUR::Word2Num converts Turkish number words into numeric values, offering a simple w2n function that takes a UTF-8 string with a Turkish numeral and returns an integer from 0 to 999,999,999 or undef if the text cannot be parsed. It is designed for cases where you need to turn spelled-out Turkish numbers into machine-readable numbers, for example in form processing, voice or chat input handling, or general text analysis. The module focuses on whole numbers and is lightweight and easy to call either by importing w2n or by using its fully qualified name. Note that input must be UTF-8 and numerals outside the supported range are not handled.

Lingua::TUR::Num2Word is a small Perl module that turns whole integers into their written Turkish equivalents. It provides the num2tur_cardinal function which accepts numbers from 0 up to 999,999,999 and returns a UTF-8 string with the number spelled out or undef for values outside that range. The module is lightweight and focused, intended for generating human-readable numbers in scripts, reports, forms, or localized output, and it can be exported on demand. It does not handle decimals, currency formatting, or other linguistic variations beyond basic cardinal numbers.