CPANscan

The "Sentinel" Perl module provides a powerful mechanism for creating lightweight scalar variables that can invoke custom get and set callbacks, making it particularly useful for defining lvalue object accessors. By utilizing the `sentinel` function, developers can easily create scalars that not only retrieve their values through specified methods but also execute code whenever a new value is assigned, allowing for more dynamic and controlled data manipulation. This module supports both direct method references and closures, optimizing performance by reducing overhead when accessing object methods. Additionally, it facilitates the automatic generation of mutation accessors, enabling seamless integration with Perl's mutation operators for simple data types. Whether implemented in XS for performance or as a pure Perl fallback, "Sentinel" enhances object-oriented programming in Perl by providing a flexible and efficient way to manage scalar values.

Geo::WeatherNWS is a Perl module designed to simplify the retrieval of current weather data from the National Weather Service (NWS). By utilizing this module, developers can easily obtain METAR formatted weather reports for any location with a four-letter station code, such as airports. The module allows customization of server settings, including FTP access credentials and directory paths, and supports both FTP and HTTP methods for data retrieval. It features a template system for generating HTML reports and includes functions for decoding raw observation strings, converting temperature and speed units, and calculating weather-related indices like heat index and wind chill. With robust error handling and the ability to access global weather data, Geo::WeatherNWS serves as a valuable tool for Perl programmers seeking to integrate weather information into their applications.

The SPVM::R module is a comprehensive implementation that brings the powerful features of the R programming language into the SPVM (Simple Perl Virtual Machine) environment, enabling users to perform advanced mathematical and statistical operations. It supports n-dimensional arrays with various data types, allowing for operations such as addition, subtraction, and complex mathematical functions, as well as data frame manipulation, which includes sorting, slicing, and conditional indexing. This module is particularly useful for developers looking to leverage R's capabilities for data analysis and manipulation directly within Perl, making it an essential tool for those working with numerical data and statistical computations.

The `SPVM::Sys` module provides a comprehensive interface for system calls related to file I/O, sockets, time management, process control, signals, and user management in the SPVM (Simple Perl Virtual Machine) environment. It allows developers to perform operations such as opening files, creating directories, managing sockets, and handling process signals with ease. The module includes methods for reading from and writing to file streams, manipulating environment variables, and retrieving system information, all while ensuring compatibility across different operating systems, including automatic handling of UTF-16LE encoding on Windows. Recent updates have improved portability by changing the C language standard to C99 and enhancing TCP keep-alive settings, making it easier to manage network connections. This module is essential for developers looking to leverage system-level functionalities within their SPVM applications.

The `SPVM::Net::SSLeay` module provides a binding to OpenSSL for the SPVM (Simple Perl Virtual Machine) environment, enabling developers to implement SSL/TLS functionality in their applications. This module encapsulates the SSL data structures and methods from OpenSSL, allowing for secure communication over networks. Users can create SSL contexts, set verification options, and perform operations such as connecting, reading, and writing data over secure sockets. Recent updates include a significant change in version 0.042, which removed the handling of `SSL_ERROR_ZERO_RETURN` to treat a return value of 0 as EOF, aligning with modern TLS practices and enhancing consistency with other libraries like IO::Socket. This module is essential for developers looking to integrate secure communication features into their SPVM applications.

The SPVM::Regex module provides a powerful interface for working with regular expressions in Perl, leveraging Google's RE2 engine for efficient pattern matching and string manipulation. It offers methods for matching patterns, replacing substrings, and splitting strings based on regex patterns, all while supporting UTF-8 and various regex features. Users can create Regex objects with custom patterns and flags, perform matches with optional offsets and lengths, and utilize both simple and callback-based replacements. Recent updates have improved performance and introduced new features, including the ability to handle mutable strings more effectively, making it a robust choice for developers needing advanced regex capabilities in their Perl applications.

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.

Net::Async::Kubernetes is an asynchronous client for interacting with Kubernetes clusters, built on the IO::Async framework. This module facilitates non-blocking communication with Kubernetes APIs, allowing developers to perform CRUD operations, retrieve logs, and manage pod executions seamlessly. It supports various authentication methods, including kubeconfig files and in-cluster service account tokens, making it versatile for different deployment scenarios. Recent updates in version 0.006 introduced an enhanced logging API that supports both one-shot and streaming modes, as well as active port-forwarding and exec functionalities, all utilizing duplex WebSocket connections for real-time interaction. This makes Net::Async::Kubernetes a powerful tool for developers looking to integrate Kubernetes management into their asynchronous Perl applications.

Kubernetes::REST is a Perl module that serves as a REST client for interacting with the Kubernetes API, simplifying the process of managing Kubernetes resources through a straightforward interface. It allows users to connect to a Kubernetes server, authenticate using bearer tokens, and perform various operations such as listing, creating, updating, patching, and deleting resources like Pods and Namespaces. The module automatically handles URL construction and resource metadata through IO::K8s classes, ensuring compatibility with different Kubernetes versions by dynamically loading resource maps from the cluster's OpenAPI specification. Additionally, it supports advanced features like watching for resource changes, retrieving logs, and executing commands within Pods, making it a comprehensive tool for developers working with Kubernetes in Perl.

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.