CPANscan

The SPVM::Go module provides an interface for utilizing goroutines and channels, key features of the Go programming language, within the SPVM (Simple Perl Virtual Machine) environment. It allows developers to create and manage concurrent tasks through goroutines, enabling efficient execution of asynchronous operations. The module includes methods for creating channels, suspending goroutines, and handling IO operations with timeouts, making it suitable for applications that require concurrency and synchronization. Recent updates have improved portability by changing the C language standard to C99 and enhanced the scheduler's functionality for sleep and IO operations, streamlining task management in concurrent programming scenarios.

The SPVM::Thread module provides a straightforward interface for creating and managing native threads in Perl, leveraging the capabilities of C++'s std::thread. With this module, developers can easily spawn new threads to execute tasks concurrently, enhancing the performance of their applications. The primary method, `new`, allows users to create a thread by passing a callback function, while the `join` method ensures that the main program waits for the thread to complete its execution. Recent updates have improved the module's exception handling by including full stack traces, making debugging easier for developers. This module is particularly useful for applications that require parallel processing or need to perform time-consuming tasks without blocking the main execution flow.

The SPVM::Time::Piece module provides a robust class for manipulating dates and times within the SPVM (Simple Perl Virtual Machine) environment. It allows users to create and manage time objects, offering methods to retrieve and format various time components such as seconds, minutes, hours, days, months, and years. With functionalities for both local and UTC time representations, users can easily convert between time zones, parse date strings, and format dates in multiple styles, including ISO 8601. The module also supports arithmetic operations on time objects, enabling users to add or subtract seconds, months, or years, and includes features for determining leap years and calculating week numbers. Overall, SPVM::Time::Piece is an essential tool for developers needing precise and flexible date and time handling in their applications.

The SPVM::Time::Local module provides functionality for converting between epoch time and structured time representations, specifically reversing the operations of the localtime and gmtime functions. It includes two primary methods: `timelocal`, which converts a Sys::Time::Tm object representing local time to epoch time, and `timegm`, which does the same for UTC time. This module is particularly useful for developers needing to manipulate time data in their applications, ensuring accurate conversions between different time formats. Recent updates have improved the module's internal structure by adopting native types and enhancing portability through a change in the C language standard to C99, reflecting ongoing maintenance and modernization efforts.

The SPVM::Compress::Raw::Zlib module provides a low-level interface to the zlib compression library, enabling Perl developers to efficiently compress and decompress data using the powerful zlib algorithms. It includes classes for both deflation and inflation processes, allowing users to easily compress data with the `gzip` method and uncompress it with the `gunzip` method, while also offering customizable options such as "AppendOutput" and "WindowBits". This module is particularly useful for applications that require data compression and decompression, making it a valuable tool for optimizing storage and transmission of data in Perl applications.

The SPVM::Unicode::Normalize module provides a set of methods for normalizing UTF-8 strings according to various Unicode normalization forms, specifically NFD (Normalization Form D), NFC (Normalization Form C), NFKD (Normalization Form KD), and NFKC (Normalization Form KC). This module is a port of Perl's Unicode::Normalize to the SPVM (Simple Perl Virtual Machine) environment, leveraging the utf8proc library for efficient processing. Each method ensures that the input string is defined and throws exceptions if the normalization fails, making it robust for handling Unicode data. Notably, the recent update (version 0.009) has improved internal handling by utilizing native types throughout the module, enhancing performance and compatibility with SPVM version 0.990143.

The SPVM::Unicode module provides a set of utilities for handling Unicode strings in Perl, enabling developers to work with various Unicode encodings seamlessly. It includes methods for parsing UTF-8 strings to extract Unicode code points, checking if a code point is a valid Unicode scalar value, and converting between UTF-8, UTF-16, and UTF-32 formats. With functionalities such as retrieving Unicode characters from strings, converting code points to UTF-8 characters, and performing bidirectional conversions between different Unicode encodings, this module simplifies the complexities of Unicode handling in Perl applications.

The SPVM::Math module provides a comprehensive set of mathematical functions and complex number operations, leveraging native C functions defined in "math.h" and "complex.h". This module allows users to perform a wide range of calculations, including trigonometric functions, logarithms, exponentiation, and complex arithmetic, all while maintaining high performance through direct integration with C libraries. Recent updates have improved portability by changing the C language standard from GNU99 to C99, and the module now requires SPVM version 0.990143 or higher, ensuring compatibility with the latest features and enhancements.

The SPVM::MIME::Base64 module provides essential methods for Base64 encoding and decoding in the SPVM (Simple Perl Virtual Machine) environment. It allows users to easily convert strings into Base64 format and vice versa, making it ideal for data transmission and storage where binary data needs to be represented in an ASCII string format. The module includes methods for encoding a string with optional line-ending sequences, decoding a Base64 string while ignoring invalid characters, and calculating the lengths of encoded and decoded strings without performing the actual encoding or decoding. With its straightforward interface and efficient handling of Base64 operations, SPVM::MIME::Base64 is a valuable tool for developers working with data serialization and MIME types.

The SPVM::Errno module provides a comprehensive interface for handling error numbers in Perl, mirroring the functionality of the C language's errno. It allows users to retrieve the current value of errno, set it, and obtain descriptive error messages corresponding to specific error codes. The module includes static methods for accessing various standard error numbers, such as EAGAIN, EACCES, and many others, while also handling exceptions for unsupported error codes. Recent updates have improved portability by switching to the C99 standard and introduced a robust testing suite to validate error constants across different operating systems. This module is essential for Perl developers needing to manage and interpret error states effectively in their applications.

The SPVM::Digest::SHA module provides a comprehensive implementation of SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512 hashing algorithms within the SPVM (Simple Perl Virtual Machine) framework. It offers both class and instance methods for generating digests in various formats, including binary, hexadecimal, and Base64. Users can easily compute hashes or HMACs by utilizing static methods or by creating an object to manage the digest state, allowing for incremental data addition. Recent updates have improved the module's internal structure by adopting native types and enhancing portability through a shift to the C99 standard, ensuring better compatibility and performance. This module is ideal for developers needing secure hashing functionalities in their SPVM applications.

The SPVM::Digest::MD5 module provides a robust implementation of the MD5 hashing algorithm, allowing users to compute MD5 digests of data efficiently. It offers both class methods for quick calculations, such as `md5` for binary output and `md5_hex` for hexadecimal representation, as well as an object-oriented interface where users can create a Digest::MD5 object, add data incrementally using the `add` method, and retrieve the final digest with either `digest` or `hexdigest`. This module is particularly useful for applications requiring data integrity verification or unique identifiers, making it a valuable tool for developers working with SPVM.

The SPVM::Resource::SocketUtil module provides a set of utilities for socket operations in the SPVM (Simple Perl Virtual Machine) environment, enabling developers to work with network sockets in C99. This resource class simplifies socket management by offering functions such as retrieving socket error numbers and handling UNIX domain sockets. It is particularly useful for applications that require network communication, especially on Windows where it interfaces with the necessary libraries like "wsock32" and "ws2_32". Recent updates have improved the module's portability by changing the C language standard from GNU99 to C99, ensuring broader compatibility across different systems.

The SPVM::Resource::Zlib module provides a resource class for integrating the zlib compression library into SPVM (Simple Perl Virtual Machine) applications. This module allows developers to leverage zlib's functionality for data compression and decompression directly within their SPVM projects, facilitating efficient handling of compressed files. Users can easily configure their SPVM environment to include this resource, enabling seamless interaction with zlib's C API. Notably, in version 1.008, released on March 10, 2026, the module transitioned to using native types throughout, enhancing performance and compatibility, while also requiring SPVM version 0.990143.

The Archive::CAR Perl module provides functionality for reading and writing Content Addressable Archive (CAR) files, which are used in the InterPlanetary File System (IPFS) to serialize IPLD blocks. This module supports both CAR v1, which features simple concatenation of blocks, and CAR v2, which includes an index for efficient random access. Users can easily load a CAR file, access its roots and blocks, and create new CAR files by specifying the roots and associated data blocks. With methods for detecting file versions and retrieving essential information about the archive structure, Archive::CAR is an essential tool for developers working with content-addressable storage systems.

The `Syntax::Construct` Perl module provides a mechanism for developers to explicitly declare non-feature syntactic constructs used in their code, which are not covered by the standard feature pragma. This module is particularly useful for ensuring compatibility with older versions of Perl by improving error messages related to unsupported constructs, thus aiding both module authors and users in identifying the necessary Perl version for proper execution. By utilizing `Syntax::Construct`, programmers can easily track and document the constructs they employ, enhancing code maintainability and facilitating smoother transitions for users running legacy Perl versions. Additionally, the module offers two subroutines, `introduced` and `removed`, allowing users to programmatically query the constructs and their corresponding Perl version introductions or removals.

MetaCPAN::Client is a versatile Perl module designed to provide a comprehensive and user-friendly interface to the MetaCPAN API, enabling developers to easily access and manipulate data related to Perl distributions, authors, modules, and more. With features that include DWIM (Do What I Mean) capabilities for intuitive searches, caching support for improved performance, and a wide array of methods for retrieving information such as authors, distributions, releases, and ratings, this module simplifies interactions with the MetaCPAN ecosystem. It is lightweight, ensuring minimal resource consumption, making it suitable for various applications, from command-line tools to long-running processes. Whether you need to find a specific module or explore recent releases, MetaCPAN::Client streamlines the process, allowing for both simple and complex queries with ease.

App::CpanDak is a Perl module that extends the functionality of cpanm (CPAN Minus) by allowing users to apply patches, set environment variables, and skip tests for specific distributions. Designed as a subclass of App::cpanminus::script, it enables customization of the installation process through special instructions stored in a designated directory, which can include patch files and YAML configuration files for various installation phases. This module is particularly useful for developers who need to modify distributions temporarily while waiting for official fixes or to adapt them to specific runtime environments. However, it is important to note that App::CpanDak is primarily a workaround and may not be compatible with future versions of cpanminus.

Business::NAB is a Perl module designed to facilitate the parsing and creation of various file formats used for financial transactions with the National Australia Bank (NAB). Serving as a top-level namespace, it links to several specialized modules, including those for handling BPAY batch payments, remittance files, Australian Direct Entry Payments, and account information files. The latest version, 0.03, introduces the capability to handle signed amounts in BAI files, enhancing its functionality for users dealing with complex financial data. This module is ideal for developers looking to integrate NAB file processing into their applications efficiently.

Module::Generic is a versatile Perl module designed to serve as a base class for creating feature-rich objects with minimal boilerplate code. It provides a framework that simplifies the creation of classes by allowing developers to define properties and their types, such as scalars, arrays, and objects, using a straightforward syntax. The module supports dynamic method generation through AUTOLOAD, enabling seamless access to object properties as methods. Recent updates in version 1.1.3 have enhanced the `colour_parse()` method for improved color messaging output and introduced new methods like `force_tty()` and `colour_max_depth()` to further refine debugging capabilities. This module is particularly useful for developers looking to streamline their object-oriented programming in Perl while maintaining robust error handling and serialization features.

Getopt::Long::Bash is a powerful Bash option parser designed to simplify the handling of command-line options in scripts, offering a user-friendly alternative to the traditional "getopts" method. It allows developers to define options in a single associative array, supporting both long and short options, automatic validation for various data types, and built-in help generation that stays synchronized with the code. This module enhances flexibility by enabling options to be mixed with arguments, supports complex data structures like arrays and hashes, and includes callback functionality for executing specific actions upon option parsing. Ideal for creating robust wrapper scripts and subcommand support, Getopt::Long::Bash streamlines the process of managing script options, making it a valuable tool for Bash developers.

Test2::Plugin::SubtestFilter is a powerful Perl module designed to enhance the Test2 testing framework by allowing developers to selectively run subtests based on their names. By setting the environment variable `SUBTEST_FILTER`, users can filter tests using substring or regex patterns, enabling focused testing during development or debugging. The plugin supports both simple and nested subtest matching, ensuring that when a parent subtest is executed, all its children are included, while non-matching siblings are skipped. Recent updates have improved functionality, including a fix for uninitialized warnings and enhanced support for eval contexts, making it a robust tool for managing complex test suites.

The Data::Random Perl module is designed to generate a variety of random data, making it particularly useful for testing and development purposes. It provides a range of functions to create random words, characters, sets, dates, times, and even images, allowing developers to easily populate their applications with unpredictable data. With customizable parameters, users can specify the size, range, and characteristics of the generated data, such as the type of characters or the dimensions of images. This flexibility makes Data::Random an essential tool for anyone looking to enhance their testing processes or simulate real-world data scenarios in Perl applications.

The `Linux::Event` module serves as a front door to the Linux event handling ecosystem, providing a unified interface for both reactor and proactor models of asynchronous I/O. By using `Linux::Event->new`, developers can create an event loop that can be configured to operate in either a readiness-based (reactor) or completion-based (proactor) manner, with explicit model selection required for clarity. This module is designed to facilitate efficient event-driven programming on Linux, leveraging underlying mechanisms like epoll and io_uring for optimal performance. Recent updates have emphasized the need for explicit model selection in the constructor, enhancing the clarity of the API and aligning documentation with the new architecture. This makes `Linux::Event` a robust choice for developers looking to implement non-blocking I/O operations in their applications.

The Bluesky Perl module is a comprehensive client library designed to facilitate interaction with the Bluesky social network, leveraging the AT protocol. It provides an object-oriented interface for users to authenticate via OAuth, create and manage posts, follow or block other users, and access real-time streaming of events. With methods for retrieving timelines, trending topics, and user profiles, as well as functionalities for direct messaging and moderation, this module simplifies the process of building applications that integrate with the Bluesky platform. Whether you're posting updates, managing social connections, or exploring content, Bluesky offers a user-friendly approach to harnessing the capabilities of the Bluesky ecosystem in Perl.

OpenAPI::Modern is a Perl module designed to validate HTTP requests and responses against OpenAPI v3.0, v3.1, or v3.2 specifications, ensuring compliance with the defined API structure. It provides a robust framework for constructing OpenAPI documents and validating incoming and outgoing messages using Mojolicious objects. The module allows developers to define their OpenAPI schema in YAML format and offers methods for validating requests and responses, retrieving specific document sections, and handling various parameter types. Notably, version 0.130 introduced caching for type inference calculations, enhancing runtime performance, making it a valuable tool for developers looking to maintain API integrity and streamline their validation processes.

Module::CoreList is a Perl module that provides comprehensive information about the core and dual-life modules included with various versions of Perl. It allows developers to easily query which modules were shipped with specific Perl releases, determine the first release of a module, check if a module is part of the core, and find deprecated or removed modules. With both a command-line utility and a functional programming API, Module::CoreList facilitates access to its data structures, enabling users to retrieve module version information, release dates, and changes between Perl versions. This module is essential for Perl developers who need to understand the evolution of core modules across different Perl versions.

The CPAN::Perl::Releases module provides a straightforward way to map Perl releases available on CPAN to their corresponding tarball locations. By utilizing the `perl_tarballs` function, users can input a specific Perl version and receive a hash reference containing the paths to the gzipped and bzip2-compressed tar files, facilitating easy access to the source code for various Perl versions. This module also includes functionality to list all supported Perl versions and the PAUSE IDs of Perl pumpkins, making it a valuable resource for developers and maintainers who need to manage or reference Perl releases efficiently.

The `Search::Tokenizer` Perl module provides a flexible and efficient way to decompose strings into tokens, or words, using customizable regular expressions and filtering options. It creates an iterator function that progressively extracts terms from a given input string, allowing for advanced features such as case folding, stopword elimination, and term modification through user-defined filters. This module is particularly designed for integration with the FTS3 full-text search engine in DBD::SQLite, but its general-purpose API makes it suitable for various text processing tasks. Users can easily create tokenizers with built-in options for locale and Unicode handling, and can also utilize built-in tokenizers for common use cases. The iterator returns detailed information about each term, including its length and position within the original string, making it a powerful tool for text analysis and search applications.

DBIx::DataModel is a powerful UML-based Object-Relational Mapping (ORM) framework for Perl that simplifies the interaction between Perl classes and relational databases. Built on top of the DBI module, it allows developers to define database schemas, tables, and relationships in a centralized manner, facilitating automatic SQL query generation, table joining, and data manipulation. With features such as customizable column types, associations, and the ability to export data in various formats, DBIx::DataModel provides a flexible and efficient way to manage database operations while maintaining a clear separation between the object-oriented and database layers. Its design emphasizes ease of use and performance, making it a valuable tool for developers looking to streamline their database interactions in Perl applications.