CPANscan

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.

Lingua::THA::Word2Num converts Thai number words into integers, making it easy to turn written Thai numerals into machine-friendly values. Its main function w2n accepts a UTF-8 Thai string and returns a numeric value for whole numbers from 0 up to 999,999,999 or undef if the text cannot be recognized. The module understands Thai special forms such as "et" for a unit one in compound numbers and "yi" for the twenty-series two. There is also an internal parser object available as tha_numerals for more advanced use. This is a lightweight utility suitable for scripting, data cleaning, localization, and simple NLP tasks that need numeric extraction from Thai text.

Lingua::THA::Num2Word is a small Perl utility that turns whole integers into their written Thai equivalents, handling numbers from 0 up to 999,999,999 and returning UTF-8 encoded Thai text. It exposes a single function, num2tha_cardinal, which accepts a number and returns the spelled-out string or undef for values outside the supported range. The module respects Thai pronunciation rules such as using "et" for a final 1 in compound numbers and "yi" for the tens position 2 in the twenties, making it useful for generating user-facing text, invoices, voice prompts, or any application that needs programmatic Thai number names.

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.

Lingua::SWA::Word2Num is a lightweight Perl module that converts Swahili number words into integer values. It provides an importable w2n function so you can turn strings like "ishirini na tatu" into 23. It supports whole numbers from 0 up to 999,999,999 and returns undef when the input text cannot be recognized. An internal parser object is also available via swa_numerals for advanced use. Use this module when you need to interpret written Swahili numerals in scripts, forms, or data processing tasks.

Lingua::SWA::Num2Word is a small Perl library that turns whole numbers into their written Swahili cardinal names, exposing a single exportable function, num2swa_cardinal, which returns a Swahili string for integers in the range 0 to 999,999,999 and returns undef for values it cannot convert. It is useful when you need human-readable Swahili numbers for reports, forms, localization or spoken prompts and is focused on cardinal number spelling rather than formatting or fractional values.

Lingua::SLK::Word2Num is a small Perl module that converts Slovak number words into numeric values. It accepts UTF-8 input and handles whole numbers in the range 0 to 999,999,999, returning an integer when parsing succeeds or undef when the text cannot be recognized. The module exposes a simple w2n function and includes an internal Slovak numeral parser, making it a handy choice for normalizing Slovak textual numerals in tasks like data entry, NLP preprocessing, or search indexing.

Lingua::SLK::Num2Word is a small Perl utility that converts whole numbers into their Slovak cardinal word forms. It offers the num2slk_cardinal function which accepts integers from 0 up to 999,999,999 and returns the number spelled out in Slovak or undef when the input is out of range. The function is exportable for easy use in scripts and modules, making this useful for localization tasks, invoice and form generation, text-to-speech prep, or any situation that needs numbers expressed in Slovak. The module only handles integer cardinal numbers and does not deal with decimals or currency formatting.

Lingua::RON::Word2Num is a Perl module that converts Romanian number words into integers, turning UTF-8 text numerals into whole numbers in the range 0 to 999,999,999. It offers an exportable w2n function that returns the numeric value or undef when the input cannot be parsed, and it also exposes an internal parser object via ron_numerals for advanced use. This module is useful for scripts and applications that need to interpret Romanian numerals in text, and it is maintained by PetaMem with initial specification by Richard C. Jelinek.

Lingua::RON::Num2Word is a Perl module that converts integers into their written Romanian cardinal form. It supports whole numbers from 0 up to 999,999,999 and returns UTF-8 encoded text, while inputs outside that range yield undef. You invoke the conversion with the num2ron_cardinal function which can be imported if desired. This module is handy for localization tasks, generating human-readable amounts for invoices and reports, producing form labels or voice prompts, and any situation where Romanian number names are needed.

Lingua::LIT::Word2Num is a small Perl module that converts Lithuanian number words into integers, making it easy to turn written numerals in Lithuanian into numeric values for scripts and applications. It expects UTF-8 input and handles whole numbers from 0 up to 999,999,999. The main routine is w2n which you can import or call with a fully qualified name and it returns the numeric value on success or undef when the text cannot be parsed. An internal lit_numerals parser object is available for more advanced usage. This module is handy for form processing, simple natural language parsing, voice transcription postprocessing, or any code that needs to understand Lithuanian numerals.

Lingua::LIT::Num2Word converts whole numbers into Lithuanian cardinal words. Its main routine num2lit_cardinal returns the spelled-out Lithuanian form for integers from 0 up to 999,999,999 and returns undef for numbers outside that range. The module handles Lithuanian declension and the hundreds component internally so the output uses grammatically correct forms. It is handy for localization, user interfaces, reports, or voice prompts where numbers must appear in Lithuanian. The module focuses on cardinal whole numbers and exposes the conversion function for optional import.

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.

Lingua::KOR::Num2Word converts whole numbers into their Korean written form using the Sino-Korean numbering system. It handles integers from 0 up to 999,999,999,999 and returns UTF-8 encoded Korean text. The module exposes a single function, num2kor_cardinal, which you call with a number to receive the spelled-out Korean string and which returns undef for values outside the supported range. This is a simple, focused utility for generating Korean cardinal number words for printing, localization, or formatted output.

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::Words2Nums is a Perl module that converts Indonesian number words into numeric values, making it easy to turn phrases like "seratus dua puluh tiga" into 123. It offers a general words2nums routine for full numbers including real and scientific notation up to the order of hundreds of trillions and a words2nums_simple routine that treats a sequence of digit words as a plain number. The module returns undef when it encounters unknown words or syntactic problems and may produce unexpected results with malformed input, so it works best on well-formed Indonesian number phrases. Use it when you need to parse numeric information from Indonesian text, forms, or simple natural language processing tasks.

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::HUN::Word2Num converts Hungarian number words into integers, handling whole numbers from 0 up to 999,999,999 and expecting UTF-8 input. You use the exported w2n function, for example Lingua::HUN::Word2Num::w2n('tizenharom'), and it returns the numeric value or undef if the text cannot be parsed. It is a simple, focused tool for form input processing, text cleanup, voice transcription postprocessing, or any script that needs to turn Hungarian numerals into machine-readable numbers. The module also exposes a hun_numerals parser object for more programmatic use.

Lingua::HUN::Num2Word is a small Perl module that converts whole numbers into their written Hungarian form, producing UTF-8 encoded text for integers from 0 to 999,999,999. You call the num2hun_cardinal function, either imported or via the full package name, and it returns the Hungarian cardinal word for the number or undef for values outside the supported range. It is handy when you need programmatic generation of Hungarian number words for reports, invoices, voice prompts, or localized text output.