This module provides details about the current CI environment. This is a perl port of https://github.com/watson/ci-info.

Questions:

• Do you think the name "CI" is appropriate?
• Do you think this module is useful?
• Any feedback is welcome.

Thanks.

Data::Ref is used to show the complete path to all elements in a complex data structure consisting of Hash and/or Arrays.

Recently I have spent a fair bit of time manipulating some deeply nested JSON structures that have been read in via some JSON package. At times it has been difficult to determine the exact data path to any particular piece of data..

In addition to being deeply nested, the data is sometimes large, and there may be many elements in each object. The net result is this; it is quite difficult at times to determine the path to any particular element, as it is usually necessary to scroll through several screens of data.

I developed Data::Ref so that I can easily see how to reference any element appearing in the data.

The included demo scripts simply do one of the following: - read in a perl script that contains only data from an object, process with eval and then walk and display the paths to each element - much the same as previous, but read data from a JSON file

See test-files/tc03.pl for the test data.

Note: the standard Markdown code blocks are not behaving in the manner I would normally expect. I will add a short demo when I learn how to do it properly.

In the meantime, please see Data::Ref README.md which contains demos.

xxHash is an extremely fast non-cryptographic hash algorithm, working at speeds close to RAM limits. It is proposed in two flavors, 32 and 64 bits, producing 32 bit or 64 bit long digest output, respectively. (See http://www.xxhash.com for details) This module is an object oriented interface of xxHash 64-bit hash functions. The interface implementation can handle data of arbitrary length and capable to run both on 32 bit and 64 bit Perl environment.

a simple tool to export browser bookmarks from CLI (Safari, Firefox and Internet Explorer). This has not been tested extensively (and contains some unorthodox code), but comments and suggestions would be welcome anyway.

SheetsApi4 is an API to Google Sheets. It is very perl-ish in that there is usually "more than one way to do it". It provides default behaviours that should be fine for most normal needs, but those behaviours can be overridden when necessary.

It is assumed that you are familiar with the Google Sheets API: https://developers.google.com/sheets/api

Module to receive data from, and control SDS011 particulate matter sensor. The module uses Device::SerialPort for communicating with sensor. Laser Dust Sensor Control Protocol v1.3 is implemented.

The Shell::Run class provides an alternative interface for executing shell commands from a perl script

Debug::Filter::PrintExpr makes use of Filter::Simple to transform specially formed comment lines into print statements for various debugging purposes.

Keyword::TailRecurse provides a tailRecurse keyword that does proper tail recursion that doesn't grow the call stack. It uses functionality added in Perl 5.14 so it's a Pure Perl solution (other current solutions use XS modules).

After using the module you can precede a function call with the keyword tailRecurse and rather adding a new entry on the call stack the function call will replace the current entry on the call stack.

note: Keyword::TailRecurse requires features Perl v5.14 and above.

Sub::Call::Tail compatability

If compatibility with Sub::Call::Tail is required then you can use the subCallTail flag to enable the tail keyword.

use Keyword::TailRecurse 'subCallTail';

sub fibonacci {
    my ( $count, $previous, $current ) = @_;

    return ( $previous // 0 ) if $count <= 0;

    $current //= 1;

    tail fibonacci ( $count - 1, $current, $previous + $current );
}

print fibonacci( 7 );

note: with Sub::Call:Tail compatibility enabled both the tailRecurse and tail keywords are available.

SEE ALSO

There's a couple of existing modules that use XS modules to provide similar functionality:

• Sub::Call::Recur

  An XS module that provides a form of tail recursion - limited to recursing into the same function it's used from.

• Sub::Call::Tail

  An XS module that provides a generic tail recursion.

The first version allowing to : - create a fragment object - compare theoretical and experimental fragments - build a metabolite|contaminant bank object - produce result ouputs

The documentation and the POD should be reworked. The code is under an internal reviewing process.

This module is a part of a future computational toolbox useful for perl developers working in bioinformatics.