Statistics::R::IO Perl interface to serialized R data
This module is a pure-Perl implementation for reading native data files produced by R statistical computing environmnent
It provides routines for reading files in the two primary file formats used in R for serializing native objects:
RDS: RDS files store a serialization of a single R object (and, if the object contains references to other objects, such as environments, all the referenced objects as well). These files are created in R using the
readRDSfunction and are typically named with the
RData: RData files store a serialization of a collection of named objects, typically a workspace. These files are created in R using the
savefunction and are typically named with the
.RDatafile extension. (Contents of the R workspace can also be saved automatically on exit to the file named
.RData, which is by default automatically read in on startup.)
Throwable::Error::NamedException Throw Errors by Name
I enjoy using Throwable::Error, however, when writing a large module, I find that my error messages get scattered throughout the code. I also find that code readability suffers when I write longer messages.
It lets you collect all your exception messages in your error class and then throw them by name. You can even customize the message if needed - or continue using Throwable::Error as before.
Devel::ParseXS Parse XS files into an abstract syntax tree
I have a need to manipulate XS files, and it'd be a lot easier to do so if one could parse them into an abstract format for further manipulation.
ExtUtils::ParseXS is a masterfully woven tapestry, but it because it weaves parsing, interpretation and code generation into a single pass, it's hard to use it to create an abstract representation.
This led me to develop Devel::ParseXS and it's companion modules in the Devel::XS::AST namespace. The parsing code closely follows the perlxs documentation, and where necessary I've used the existing behavior of ExtUtils::ParseXS to disambiguate a few things.
Currently the parsing is pretty complete; not everything is further translated into a useable AST object. Prior to releasing this to CPAN, I'd like to get some feedback on the module names.
Devel::ParseXS and Devel::XS::AST sound good to me.
Data::Handle::KeyValue A consistent interface for retrieving rows of hash refs
Various data sources like a CSV file, a SQL database, or an array of hash refs can store information in a similar way. In particular, each 'row' can be represented as a hash.
There are various modules for retrieving information from them like Text::CSV and DBI; however, each has it's own syntax. Further, there's a fair amount of boiler-plate we need to do to get back a live data handle.
The Data::Handle::KeyValue classes do the preliminary work for us and provide a consistent interface to retrieve our data.
This eases construction and simplifies the API we need to remember.
It also abstracts the data source from how we retrieve it. This in turn lets us change our upstream data source without changing any downstream code.
TAP::Formatter::BambooAlt A TAP formatter that outputs in a format that is useful to Bamboo.
This is another TAP formatter for Bamboo. The primary difference between this module and the existing TAP::Formatter::Bamboo is that this one will return a separate failure/success for each test in the test script along with its name and results in a format acceptable to Bamboo. This makes it such that Bamboo can track tests that have failed over time by individual test rather than just by test file.
Params::Validate::Array Provides an alternative version of Params::Validate::validate() which returns args as an list, not a hash
Yet Another Params::Validate::XXX module.
I like my validate() to return args as a list instead of a hash, and without having to resort to the more complicated call of P::V::validate_with()
This module changes only the behaviour of P::V::validate() and only when the descriptor is an arrayref (as it has to be to preserve the order of the args). If P::V::A::validate() is called with a hashref descriptor, it reverts to P::V::validate()'s behaviour.
All other PVA routines are simple pass-throughs to P::V (except for P::V::A::validation_options() which might increment a stack_skip => ... arg to hide the extra layer of call stack). P::V::A::validate() is a relatively simple wrapper around P::V::validate().
Util::Underscore Common helper functions without having to import them
This module contains various utility functions, and makes them accessible through the "_" package. This allows the use of these utilities (a) without much per-usage overhead and (b) without namespace pollution.
It contains functions from the following modules:
Safe::Isa, which contains convenience functions for
Not all functions from those are available, and some have been renamed.
The module has shipped, and can be installed like
cpanm Util::Underscore. Feedback is of course still welcome.