Venus

Standard Library

Standard Library for Perl 5

function: after function: all function: any function: args function: around function: array function: arrayref function: assert function: async function: atom function: await function: before function: bool function: box function: call function: cast function: catch function: caught function: chain function: check function: clargs function: cli function: clone function: code function: collect function: concat function: config function: cop function: data function: date function: enum function: error function: factory function: false function: fault function: flat function: float function: future function: gather function: gets function: handle function: hash function: hashref function: hook function: in function: is function: is_arrayref function: is_blessed function: is_boolean function: is_coderef function: is_dirhandle function: is_enum function: is_error function: is_false function: is_fault function: is_filehandle function: is_float function: is_glob function: is_hashref function: is_number function: is_object function: is_package function: is_reference function: is_regexp function: is_scalarref function: is_string function: is_true function: is_undef function: is_value function: is_yesno function: json function: kvargs function: list function: load function: log function: make function: map function: match function: merge function: merge_flat function: merge_flat_mutate function: merge_join function: merge_join_mutate function: merge_keep function: merge_keep_mutate function: merge_swap function: merge_swap_mutate function: merge_take function: merge_take_mutate function: meta function: name function: number function: opts function: pairs function: path function: perl function: process function: proto function: puts function: raise function: random function: range function: read_env function: read_env_file function: read_json function: read_json_file function: read_perl function: read_perl_file function: read_yaml function: read_yaml_file function: regexp function: render function: replace function: roll function: schema function: search function: set function: sets function: sorts function: space function: string function: syscall function: template function: test function: text_pod function: text_pod_string function: text_tag function: text_tag_string function: then function: throw function: true function: try function: tv function: type function: unpack function: vars function: vns function: what function: work function: wrap function: write_env function: write_env_file function: write_json function: write_json_file function: write_perl function: write_perl_file function: write_yaml function: write_yaml_file function: yaml

package main;

use Venus 'catch', 'error', 'raise';

# error handling
my ($error, $result) = catch {
  error;
};

# boolean keywords
if ($result) {
  error;
}

# raise exceptions
if ($result) {
  raise 'MyApp::Error';
}

# boolean keywords, and more!
my $bool = true ne false;

This library provides an object-orientation framework and extendible standard library for Perl 5 with classes which wrap most native Perl data types. Venus has a simple modular architecture, robust library of classes, methods, and roles, supports pure-Perl autoboxing, advanced exception handling, "true" and "false" functions, package introspection, command-line options parsing, and more. This package will always automatically exports true and false keyword functions (unless existing routines of the same name already exist in the calling package or its parents), otherwise exports keyword functions as requested at import. This library requires Perl 5.18+.

+=head1 CAPABILITIES

The following is a short list of capabilities:

+=over 4

+=item *

Perl 5.18.0+

+=item *

Zero Dependencies

+=item *

Fast Object-Orientation

+=item *

Robust Standard Library

+=item *

Intuitive Value Classes

+=item *

Pure Perl Autoboxing

+=item *

Convenient Utility Classes

+=item *

Simple Package Reflection

+=item *

Flexible Exception Handling

+=item *

Composable Standards

+=item *

Pluggable (no monkeypatching)

+=item *

Proxyable Methods

+=item *

Type Assertions

+=item *

Type Coercions

+=item *

Value Casting

+=item *

Boolean Values

+=item *

Complete Documentation

+=item *

Complete Test Coverage

+=back

The after function installs a method modifier that executes after the original method, allowing you to perform actions after a method call. Note: The return value of the modifier routine is ignored; the wrapped method always returns the value from the original method. Modifiers are executed in the order they are stacked. This function is always exported unless a routine of the same name already exists.

after(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 after

package Example;

use Venus::Class 'after', 'attr';

attr 'calls';

sub BUILD {
  my ($self) = @_;
  $self->calls([]);
}

sub test {
  my ($self) = @_;
  push @{$self->calls}, 'original';
  return 'original';
}

after 'test', sub {
  my ($self) = @_;
  push @{$self->calls}, 'after';
  return 'ignored';
};

package main;

my $example = Example->new;
my $value = $example->test;

# "original"

The all function accepts an arrayref, hashref, or "mappable" and returns true if the rvalue is a callback and returns true for all items in the collection. If the rvalue provided is not a coderef that value's type and value will be used as the criteria.

all(arrayref | hashref | consumes[Venus::Role::Mappable] $lvalue, any $rvalue) (boolean)

{ since => '4.15', }

The any function accepts an arrayref, hashref, or "mappable" and returns true if the rvalue is a callback and returns true for any items in the collection. If the rvalue provided is not a coderef that value's type and value will be used as the criteria.

any(arrayref | hashref | consumes[Venus::Role::Mappable] $lvalue, any $rvalue) (boolean)

{ since => '4.15', }

The args function builds and returns a Venus::Args object, or dispatches to the coderef or method provided.

args(arrayref $value, string | coderef $code, any @args) (any)

{ since => '3.10', }

The around function installs a method modifier that wraps around the original method, giving you complete control over its execution. The modifier receives the original method as its first argument, followed by the method's arguments, and must explicitly call the original method if desired.

around(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 around

package Example3;

use Venus::Class 'around', 'attr';

sub test {
  my ($self, $value) = @_;
  return $value;
}

around 'test', sub {
  my ($orig, $self, $value) = @_;
  my $result = $self->$orig($value);
  return $result * 2;
};

package main;

my $result = Example3->new->test(5);

# 10

The array function builds and returns a Venus::Array object, or dispatches to the coderef or method provided.

array(arrayref | hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The arrayref function takes a list of arguments and returns a arrayref.

arrayref(any @args) (arrayref)

{ since => '3.10', }

=example-1 arrayref

package main;

use Venus 'arrayref';

my $arrayref = arrayref(content => 'example');

# [content => "example"]

The assert function builds a Venus::Assert object and returns the result of a "validate" in Venus::Assert operation.

assert(any $data, string $expr) (any)

{ since => '2.40', }

The async function accepts a callback and executes it asynchronously via "future" in Venus::Process. This function returns a Venus::Future object which can be fulfilled via "wait" in Venus::Future.

async(coderef $code, any @args) (Venus::Future)

{ since => '3.40', }

The atom function builds and returns a Venus::Atom object.

atom(any $value) (Venus::Atom)

{ since => '3.55', }

The await function accepts a Venus::Future object and eventually returns a value (or values) for it. The value(s) returned are the return values or emissions from the asychronous callback executed with "async" which produced the process object.

await(Venus::Future $future, number $timeout) (any)

{ since => '3.40', }

The before function installs a method modifier that executes before the original method, allowing you to perform actions before a method call. Note: The return value of the modifier routine is ignored; the wrapped method always returns the value from the original method. Modifiers are executed in the order they are stacked. This function is always exported unless a routine of the same name already exists.

before(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 before

package Example5;

use Venus::Class 'attr', 'before';

attr 'calls';

sub BUILD {
  my ($self) = @_;
  $self->calls([]);
}

sub test {
  my ($self) = @_;
  push @{$self->calls}, 'original';
  return $self;
}

before 'test', sub {
  my ($self) = @_;
  push @{$self->calls}, 'before';
  return $self;
};

package main;

my $example = Example5->new;
$example->test;
my $calls = $example->calls;

# ['before', 'original']

The bool function builds and returns a Venus::Boolean object.

bool(any $value) (Venus::Boolean)

{ since => '2.55', }

The box function returns a Venus::Box object for the argument provided.

box(any $data) (Venus::Box)

{ since => '2.32', }

=example-1 box

package main;

use Venus 'box';

my $box = box({});

# bless({value => bless({value => {}}, 'Venus::Hash')}, 'Venus::Box')

The call function dispatches function and method calls to a package and returns the result.

call(string | object | coderef $data, any @args) (any)

{ since => '2.32', }

=example-1 call

package main;

use Venus 'call';

require Digest::SHA;

my $result = call(\'Digest::SHA', 'new');

# bless(do{\(my $o = '...')}, 'digest::sha')

The cast function returns the argument provided as an object, promoting native Perl data types to data type objects. The optional second argument can be the name of the type for the object to cast to explicitly.

cast(any $data, string $type) (object)

{ since => '1.40', }

=example-1 cast

package main;

use Venus 'cast';

my $undef = cast;

# bless({value => undef}, "Venus::Undef")

The catch function executes the code block trapping errors and returning the caught exception in scalar context, and also returning the result as a second argument in list context.

catch(coderef $block) (Venus::Error, any)

{ since => '0.01', }

=example-1 catch

package main;

use Venus 'catch';

my $error = catch {die};

$error;

# "Died at ..."

The caught function evaluates the exception object provided and validates its identity and name (if provided) then executes the code block provided returning the result of the callback. If no callback is provided this function returns the exception object on success and undef on failure.

caught(object $error, string | tuple[string, string] $identity, coderef $block) (any)

{ since => '1.95', }

=example-1 caught

package main;

use Venus 'catch', 'caught', 'error';

my $error = catch { error };

my $result = caught $error, 'Venus::Error';

# bless(..., 'Venus::Error')

The chain function chains function and method calls to a package (and return values) and returns the result.

chain(string | object | coderef $self, string | within[arrayref, string] @args) (any)

{ since => '2.32', }

=example-1 chain

package main;

use Venus 'chain';

my $result = chain('Venus::Path', ['new', 't'], 'exists');

# 1

The check function builds a Venus::Assert object and returns the result of a "check" in Venus::Assert operation.

check(any $data, string $expr) (boolean)

{ since => '2.40', }

The clargs function accepts a single arrayref of Getopt::Long specs, or an arrayref of arguments followed by an arrayref of Getopt::Long specs, and returns a three element list of Venus::Args, Venus::Opts, and Venus::Vars objects. If only a single arrayref is provided, the arguments will be taken from @ARGV. If this function is called in scalar context only the Venus::Opts object will be returned.

clargs(arrayref $args, arrayref $spec) (Venus::Args, Venus::Opts, Venus::Vars)

{ since => '3.10', }

The cli function builds and returns a Venus::Cli object.

cli(arrayref $args) (Venus::Cli)

{ since => '2.55', }

The clone function uses "dclone" in Storable to perform a deep clone of the reference provided and returns a copy.

clone(ref $value) (ref)

{ since => '3.55', }

The code function builds and returns a Venus::Code object, or dispatches to the coderef or method provided.

code(coderef $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The concat function stringifies and "joins" multiple values delimited by a single space and returns the resulting string.

concat(any @args) (string)

{ since => '4.15', }

The config function builds and returns a Venus::Config object, or dispatches to the coderef or method provided.

config(hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The collect function uses Venus::Collect to iterate over the value and selectively transform or filter the data. The function supports both list-like and hash-like data structures, handling key/value iteration when applicable.

collect(any $value, coderef $code) (any)

{ since => '4.15', }

The cop function attempts to curry the given subroutine on the object or class and if successful returns a closure.

cop(string | object | coderef $self, string $name) (coderef)

{ since => '2.32', }

=example-1 cop

package main;

use Venus 'cop';

my $coderef = cop('Digest::SHA', 'sha1_hex');

# sub { ... }

The data function builds and returns a Venus::Data object, or dispatches to the coderef or method provided.

data(any $value, string | coderef $code, any @args) (any)

{ since => '4.15', }

The date function builds and returns a Venus::Date object, or dispatches to the coderef or method provided.

date(number $value, string | coderef $code, any @args) (any)

{ since => '2.40', }

The enum function builds and returns a Venus::Enum object.

enum(arrayref | hashref $value) (Venus::Enum)

{ since => '3.55', }

The error function throws a Venus::Error exception object using the exception object arguments provided.

error(maybe[hashref] $args) (Venus::Error)

{ since => '0.01', }

=example-1 error

package main;

use Venus 'error';

my $error = error;

# bless({...}, 'Venus::Error')

The factory function builds and returns a Venus::Factory object, or dispatches to the coderef or method provided.

factory(hashref $value, string | coderef $code, any @args) (any)

{ since => '4.15', }

The false function returns a falsy boolean value which is designed to be practically indistinguishable from the conventional numerical 0 value.

false() (boolean)

{ since => '0.01', }

=example-1 false

package main;

use Venus;

my $false = false;

# 0

The fault function throws a Venus::Fault exception object and represents a system failure, and isn't meant to be caught.

fault(string $args) (Venus::Fault)

{ since => '1.80', }

=example-1 fault

package main;

use Venus 'fault';

my $fault = fault;

# bless({message => 'Exception!'}, 'Venus::Fault')

The flat function take a list of arguments and flattens them where possible and returns the list of flattened values. When a hashref is encountered, it will be flattened into key/value pairs. When an arrayref is encountered, it will be flattened into a list of items.

flat(any @args) (any)

{ since => '4.15', }

The float function builds and returns a Venus::Float object, or dispatches to the coderef or method provided.

float(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The future function builds and returns a Venus::Future object.

future(coderef $code) (Venus::Future)

{ since => '3.55', }

The gather function builds a Venus::Gather object, passing it and the value provided to the callback provided, and returns the return value from "result" in Venus::Gather.

gather(any $value, coderef $callback) (any)

{ since => '2.50', }

The gets function select values from within the underlying data structure using "path" in Venus::Array or "path" in Venus::Hash, where each argument is a selector, returns all the values selected. Returns a list in list context.

gets(string @args) (arrayref)

{ since => '4.15', }

The handle function installs a method modifier that wraps a method similar to "around", but is the low-level implementation. The modifier receives the original method as its first argument (which may be undef if the method doesn't exist), followed by the method's arguments. This is the foundation for the other method modifiers.

handle(string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 handle

package Example7;

use Venus::Class 'handle';

sub test {
  my ($self, $value) = @_;
  return $value;
}

handle 'test', sub {
  my ($orig, $self, $value) = @_;
  return $orig ? $self->$orig($value * 2) : 0;
};

package main;

my $result = Example7->new->test(5);

# 10

The hash function builds and returns a Venus::Hash object, or dispatches to the coderef or method provided.

hash(hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The hashref function takes a list of arguments and returns a hashref.

hashref(any @args) (hashref)

{ since => '3.10', }

=example-1 hashref

package main;

use Venus 'hashref';

my $hashref = hashref(content => 'example');

# {content => "example"}

The hook function is a specialized method modifier helper that applies a modifier (after, around, before, or handle) to a lifecycle hook method. It automatically uppercases the hook name, making it convenient for modifying Venus lifecycle hooks like BUILD, BLESS, BUILDARGS, and AUDIT.

hook(string $type, string $name, coderef $code) (coderef)

{ since => '4.15', }

=example-1 hook

package Example9;

use Venus::Class 'attr', 'hook';

attr 'startup';

sub BUILD {
  my ($self, $args) = @_;
  $self->startup('original');
}

hook 'after', 'build', sub {
  my ($self) = @_;
  $self->startup('modified');
};

package main;

my $result = Example9->new->startup;

# "modified"

The in function accepts an arrayref, hashref, or "mappable" and returns true if the type and value of the rvalue is the same for any items in the collection.

in(arrayref | hashref | consumes[Venus::Role::Mappable] $lvalue, any $rvalue) (boolean)

{ since => '4.15', }

The is function returns true if the lvalue and rvalue are identical, i.e. refers to the same memory address, otherwise returns false.

is(any $lvalue, any $rvalue) (boolean)

{ since => '4.15', }

The is_blessed function uses "check" to validate that the data provided is an object returns true, otherwise returns false.

is_blessed(any $data) (boolean)

{ since => '4.15', }

The is_boolean function uses "check" to validate that the data provided is a boolean returns true, otherwise returns false.

is_boolean(any $data) (boolean)

{ since => '4.15', }

The is_coderef function uses "check" to validate that the data provided is a coderef returns true, otherwise returns false.

is_coderef(any $data) (boolean)

{ since => '4.15', }

The is_dirhandle function uses "check" to validate that the data provided is a dirhandle returns true, otherwise returns false.

is_dirhandle(any $data) (boolean)

{ since => '4.15', }

The is_enum function uses "check" to validate that the data provided is an enum returns true, otherwise returns false.

is_enum(any $data, value @args) (boolean)

{ since => '4.15', }

The is_error function accepts a scalar value and returns true if the value is (or is derived from) Venus::Error. This function can dispatch method calls and execute callbacks, and returns true of the return value from the callback is truthy, and false otherwise.

is_error(any $data, string | coderef $code, any @args) (boolean)

{ since => '4.15', }

The is_false function accepts a scalar value and returns true if the value is falsy. This function can dispatch method calls and execute callbacks.

is_false(any $data, string | coderef $code, any @args) (boolean)

{ since => '3.04', }

The is_fault function accepts a scalar value and returns true if the value is (or is derived from) Venus::Fault.

is_fault(any $data) (boolean)

{ since => '4.15', }

The is_filehandle function uses "check" to validate that the data provided is a filehandle returns true, otherwise returns false.

is_filehandle(any $data) (boolean)

{ since => '4.15', }

The is_float function uses "check" to validate that the data provided is a float returns true, otherwise returns false.

is_float(any $data) (boolean)

{ since => '4.15', }

The is_glob function uses "check" to validate that the data provided is a glob returns true, otherwise returns false.

is_glob(any $data) (boolean)

{ since => '4.15', }

The is_hashref function uses "check" to validate that the data provided is a hashref returns true, otherwise returns false.

is_hashref(any $data) (boolean)

{ since => '4.15', }

The is_number function uses "check" to validate that the data provided is a number returns true, otherwise returns false.

is_number(any $data) (boolean)

{ since => '4.15', }

The is_object function uses "check" to validate that the data provided is an object returns true, otherwise returns false.

is_object(any $data) (boolean)

{ since => '4.15', }

The is_package function uses "check" to validate that the data provided is a package returns true, otherwise returns false.

is_package(any $data) (boolean)

{ since => '4.15', }

The is_reference function uses "check" to validate that the data provided is a reference returns true, otherwise returns false.

is_reference(any $data) (boolean)

{ since => '4.15', }

The is_regexp function uses "check" to validate that the data provided is a regexp returns true, otherwise returns false.

is_regexp(any $data) (boolean)

{ since => '4.15', }

The is_scalarref function uses "check" to validate that the data provided is a scalarref returns true, otherwise returns false.

is_scalarref(any $data) (boolean)

{ since => '4.15', }

The is_string function uses "check" to validate that the data provided is a string returns true, otherwise returns false.

is_string(any $data) (boolean)

{ since => '4.15', }

The is_true function accepts a scalar value and returns true if the value is truthy. This function can dispatch method calls and execute callbacks.

is_true(any $data, string | coderef $code, any @args) (boolean)

{ since => '3.04', }

The is_undef function uses "check" to validate that the data provided is an undef returns true, otherwise returns false.

is_undef(any $data) (boolean)

{ since => '4.15', }

The is_value function uses "check" to validate that the data provided is an value returns true, otherwise returns false.

is_value(any $data) (boolean)

{ since => '4.15', }

The is_yesno function uses "check" to validate that the data provided is a yesno returns true, otherwise returns false.

is_yesno(any $data) (boolean)

{ since => '4.15', }

The json function builds a Venus::Json object and will either "decode" in Venus::Json or "encode" in Venus::Json based on the argument provided and returns the result.

json(string $call, any $data) (any)

{ since => '2.40', }

The kvargs function takes a list of arguments and returns a hashref. If a single hashref is provided, it is returned as-is. Otherwise, the arguments are treated as key-value pairs. If an odd number of arguments is provided, the last key will have undef as its value.

kvargs(any @args) (hashref)

{ since => '5.00', }

The list function accepts a list of values and flattens any arrayrefs, returning a list of scalars.

list(any @args) (any)

{ since => '3.04', }

The load function loads the package provided and returns a Venus::Space object.

load(any $name) (Venus::Space)

{ since => '2.32', }

=example-1 load

package main;

use Venus 'load';

my $space = load 'Venus::Scalar';

# bless({value => 'Venus::Scalar'}, 'Venus::Space')

The log function prints the arguments provided to STDOUT, stringifying complex values, and returns a Venus::Log object. If the first argument is a log level name, e.g. debug, error, fatal, info, trace, or warn, it will be used when emitting the event. The desired log level is specified by the VENUS_LOG_LEVEL environment variable and defaults to trace.

log(any @args) (Venus::Log)

{ since => '2.40', }

The make function "calls" the new routine on the invocant and returns the result which should be a package string or an object.

make(string $package, any @args) (any)

{ since => '2.32', }

=example-1 make

package main;

use Venus 'make';

my $made = make('Digest::SHA');

# bless(do{\(my $o = '...')}, 'Digest::SHA')

The map function returns a Venus::Map object for the hashref provided.

map(hashref $value) (Venus::Map)

{ since => '4.15', }

=example-1 map

package main;

use Venus;

my $map = Venus::map {1..4};

# bless(..., 'Venus::Map')

The match function builds a Venus::Match object, passing it and the value provided to the callback provided, and returns the return value from "result" in Venus::Match.

match(any $value, coderef $callback) (any)

{ since => '2.50', }

The merge function returns a value which is a merger of all of the arguments provided. This function is an alias for "merge_join" given the principle of least surprise.

merge(any @args) (any)

{ since => '2.32', }

=example-1 merge

package main;

use Venus 'merge';

my $merged = merge({1..4}, {5, 6});

# {1..6}

The merge_flat function merges two (or more) values and returns a new values based on the types of the inputs:

Note: This function appends hashref values to an arrayref when encountered.

+=over 4

+=item * When the lvalue is a "scalar" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "hashref" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "scalar" we append the rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "arrayref" we append the items in rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "hashref" we append the values in rvalue to the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "hashref" we append the keys and values in rvalue to the lvalue, overwriting existing keys where there's overlap.

+=back

merge_flat(any @args) (any)

{ since => '4.15', }

The merge_flat_mutate performs a merge operaiton in accordance with "merge_flat" except that it mutates the values being merged and returns the mutated value.

merge_flat_mutate(any @args) (any)

{ since => '4.15', }

The merge_join merges two (or more) values and returns a new values based on the types of the inputs:

Note: This function merges hashrefs with hashrefs, and appends arrayrefs with arrayrefs.

+=over 4

+=item * When the lvalue is a "scalar" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "hashref" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "scalar" we append the rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "arrayref" we append the items in rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "hashref" we append the rvalue to the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "hashref" we append the keys and values in rvalue to the lvalue, overwriting existing keys where there's overlap.

+=back

merge_join(any @args) (any)

{ since => '4.15', }

The merge_join_mutate performs a merge operaiton in accordance with "merge_join" except that it mutates the values being merged and returns the mutated value.

merge_join_mutate(any @args) (any)

{ since => '4.15', }

The merge_keep function merges two (or more) values and returns a new values based on the types of the inputs:

Note: This function retains the existing data, appends arrayrefs with arrayrefs, and only merges new keys and values when merging hashrefs with hashrefs.

+=over 4

+=item * When the lvalue is a "scalar" and the rvalue is a "scalar" we keep the lvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "arrayref" we keep the lvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "hashref" we keep the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "scalar" we append the rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "arrayref" we append the items in rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "hashref" we append the rvalue to the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "scalar" we keep the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "arrayref" we keep the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "hashref" we append the keys and values in rvalue to the lvalue, but without overwriting existing keys if there's overlap.

+=back

merge_keep(any @args) (any)

{ since => '4.15', }

The merge_keep_mutate performs a merge operaiton in accordance with "merge_keep" except that it mutates the values being merged and returns the mutated value.

merge_keep_mutate(any @args) (any)

{ since => '4.15', }

The merge_swap function merges two (or more) values and returns a new values based on the types of the inputs:

Note: This function replaces the existing data, including when merging hashrefs with hashrefs, and overwrites values (instead of appending) when merging arrayrefs with arrayrefs.

+=over 4

+=item * When the lvalue is a "scalar" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "hashref" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "scalar" we append the rvalue to the lvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "arrayref" we replace each items in lvalue with the value at the corresponding position in the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "hashref" we append the rvalue to the lvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "hashref" we append the keys and values in rvalue to the lvalue, overwriting existing keys if there's overlap.

+=back

merge_swap(any @args) (any)

{ since => '4.15', }

The merge_swap_mutate performs a merge operaiton in accordance with "merge_swap" except that it mutates the values being merged and returns the mutated value.

merge_swap_mutate(any @args) (any)

{ since => '4.15', }

The merge_take function merges two (or more) values and returns a new values based on the types of the inputs:

Note: This function always "takes" the new value, does not append arrayrefs, and overwrites keys and values when merging hashrefs with hashrefs.

+=over 4

+=item * When the lvalue is a "scalar" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "scalar" and the rvalue is a "hashref" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "arrayref" and the rvalue is a "hashref" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "scalar" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "arrayref" we keep the rvalue.

+=item * When the lvalue is a "hashref" and the rvalue is a "hashref" we append the keys and values in rvalue to the lvalue, overwriting existing keys if there's overlap.

+=back

merge_take(any @args) (any)

{ since => '4.15', }

The merge_take_mutate performs a merge operaiton in accordance with "merge_take" except that it mutates the values being merged and returns the mutated value.

merge_take_mutate(any @args) (any)

{ since => '4.15', }

The meta function builds and returns a Venus::Meta object, or dispatches to the coderef or method provided.

meta(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The name function builds and returns a Venus::Name object, or dispatches to the coderef or method provided.

name(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The number function builds and returns a Venus::Number object, or dispatches to the coderef or method provided.

number(Num $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The opts function builds and returns a Venus::Opts object, or dispatches to the coderef or method provided.

opts(arrayref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The pairs function accepts an arrayref or hashref and returns an arrayref of arrayrefs holding keys (or indices) and values. The function returns an empty arrayref for all other values provided. Returns a list in list context.

pairs(any $data) (arrayref)

{ since => '3.04', }

The path function builds and returns a Venus::Path object, or dispatches to the coderef or method provided.

path(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The perl function builds a Venus::Dump object and will either "decode" in Venus::Dump or "encode" in Venus::Dump based on the argument provided and returns the result.

perl(string $call, any $data) (any)

{ since => '2.40', }

The process function builds and returns a Venus::Process object, or dispatches to the coderef or method provided.

process(string | coderef $code, any @args) (any)

{ since => '2.55', }

The proto function builds and returns a Venus::Prototype object, or dispatches to the coderef or method provided.

proto(hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The puts function select values from within the underlying data structure using "path" in Venus::Array or "path" in Venus::Hash, optionally assigning the value to the preceeding scalar reference and returns all the values selected.

puts(any @args) (arrayref)

{ since => '3.20', }

The raise function generates and throws a named exception object derived from Venus::Error, or provided base class, using the exception object arguments provided.

raise(string $class | tuple[string, string] $class, any @args) (Venus::Error)

{ since => '0.01', }

=example-1 raise

package main;

use Venus 'raise';

my $error = raise 'MyApp::Error';

# bless({...}, 'MyApp::Error')

The random function builds and returns a Venus::Random object, or dispatches to the coderef or method provided.

random(string | coderef $code, any @args) (any)

{ since => '2.55', }

The range function returns the result of a "range" in Venus::Array operation.

range(number | string @args) (arrayref)

{ since => '3.20', }

The read_env function returns a new Venus::Config object based on the string of key/value pairs provided.

read_env(string $data) (Venus::Config)

{ since => '4.15', }

The read_env_file function uses Venus::Path to return a new Venus::Config object based on the file provided.

read_env_file(string $file) (Venus::Config)

{ since => '4.15', }

=example-1 read_env_file

package main;

use Venus 'read_env_file';

my $config = read_env_file 't/conf/read.env';

# bless(..., 'Venus::Config')

The read_json function returns a new Venus::Config object based on the JSON string provided.

read_json(string $data) (Venus::Config)

{ since => '4.15', }

=example-1 read_json

package main;

use Venus 'read_json';

my $config = read_json q(
{
  "$metadata": {
    "tmplog": "/tmp/log"
  },
  "$services": {
    "log": { "package": "Venus/Path", "argument": { "$metadata": "tmplog" } }
  }
}
);

# bless(..., 'Venus::Config')

The read_json_file function uses Venus::Path to return a new Venus::Config object based on the file provided.

read_json_file(string $file) (Venus::Config)

{ since => '4.15', }

=example-1 read_json_file

package main;

use Venus 'read_json_file';

my $config = read_json_file 't/conf/read.json';

# bless(..., 'Venus::Config')

The read_perl function returns a new Venus::Config object based on the Perl string provided.

read_perl(string $data) (Venus::Config)

{ since => '4.15', }

=example-1 read_perl

package main;

use Venus 'read_perl';

my $config = read_perl q(
{
  '$metadata' => {
    tmplog => "/tmp/log"
  },
  '$services' => {
    log => { package => "Venus/Path", argument => { '$metadata' => "tmplog" } }
  }
}
);

# bless(..., 'Venus::Config')

The read_perl_file function uses Venus::Path to return a new Venus::Config object based on the file provided.

read_perl_file(string $file) (Venus::Config)

{ since => '4.15', }

=example-1 read_perl_file

package main;

use Venus 'read_perl_file';

my $config = read_perl_file 't/conf/read.perl';

# bless(..., 'Venus::Config')

The read_yaml function returns a new Venus::Config object based on the YAML string provided.

read_yaml(string $data) (Venus::Config)

{ since => '4.15', }

=example-1 read_yaml

package main;

use Venus 'read_yaml';

my $config = read_yaml q(
'$metadata':
  tmplog: /tmp/log
'$services':
  log:
    package: "Venus/Path"
    argument:
      '$metadata': tmplog
);

# bless(..., 'Venus::Config')

The read_yaml_file function uses Venus::Path to return a new Venus::Config object based on the YAML string provided.

read_yaml_file(string $file) (Venus::Config)

{ since => '4.15', }

=example-1 read_yaml_file

package main;

use Venus 'read_yaml_file';

my $config = read_yaml_file 't/conf/read.yaml';

# bless(..., 'Venus::Config')

The regexp function builds and returns a Venus::Regexp object, or dispatches to the coderef or method provided.

regexp(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The render function accepts a string as a template and renders it using Venus::Template, and returns the result.

render(string $data, hashref $args) (string)

{ since => '3.04', }

The replace function builds and returns a Venus::Replace object, or dispatches to the coderef or method provided.

replace(arrayref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The roll function takes a list of arguments, assuming the first argument is invokable, and reorders the list such that the routine name provided comes after the invocant (i.e. the 1st argument), creating a list acceptable to the "call" function.

roll(string $name, any @args) (any)

{ since => '2.32', }

=example-1 roll

package main;

use Venus 'roll';

my @list = roll('sha1_hex', 'Digest::SHA');

# ('Digest::SHA', 'sha1_hex');

The search function builds and returns a Venus::Search object, or dispatches to the coderef or method provided.

search(arrayref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The set function returns a Venus::Set object for the arrayref provided.

set(arrayref $value) (Venus::Set)

{ since => '4.11', }

=example-1 set

package main;

use Venus;

my $set = Venus::set [1..9];

# bless(..., 'Venus::Set')

The space function returns a Venus::Space object for the package provided.

space(any $name) (Venus::Space)

{ since => '2.32', }

=example-1 space

package main;

use Venus 'space';

my $space = space 'Venus::Scalar';

# bless({value => 'Venus::Scalar'}, 'Venus::Space')

The schema function builds and returns a Venus::Schema object, or dispatches to the coderef or method provided.

schema(string | coderef $code, any @args) (Venus::Schema)

{ since => '4.15', }

The sets function find values from within the underlying data structure using "path" in Venus::Array or "path" in Venus::Hash, where each argument pair is a selector and value, and returns all the values provided. Returns a list in list context. Note, nested data structures can be updated but not created.

sets(string @args) (arrayref)

{ since => '4.15', }

The sorts function accepts a list of values, flattens any arrayrefs, and sorts it using the default sort(LIST) call style exclusively.

sorts(any @args) (any)

{ since => '4.15', }

The string function builds and returns a Venus::String object, or dispatches to the coderef or method provided.

string(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The syscall function perlforms system call, i.e. a "qx" in perlfunc operation, and returns true if the command succeeds, otherwise returns false. In list context, returns the output of the operation and the exit code.

syscall(number | string @args) (any)

{ since => '3.04', }

The template function builds and returns a Venus::Template object, or dispatches to the coderef or method provided.

template(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The test function builds and returns a Venus::Test object, or dispatches to the coderef or method provided.

test(string $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The text_pod function builds and returns a Venus::Text::Pod object, or dispatches to the coderef or method provided.

text_pod(string $value, string | coderef $code, any @args) (any)

{ since => '4.15', }

The text_pod_string function builds a Venus::Text::Pod object for the current file, i.e. "__FILE__" in perlfunc or script, i.e. $0, and returns the result of a "string" in Venus::Text::Pod operation using the arguments provided.

text_pod_string(any @args) (any)

{ since => '4.15', }

The text_tag function builds and returns a Venus::Text::Tag object, or dispatches to the coderef or method provided.

text_tag(string $value, string | coderef $code, any @args) (any)

{ since => '4.15', }

The text_tag_string function builds a Venus::Text::Tag object for the current file, i.e. "__FILE__" in perlfunc or script, i.e. $0, and returns the result of a "string" in Venus::Text::Tag operation using the arguments provided.

text_tag_string(any @args) (any)

{ since => '4.15', }

The then function proxies the call request to the "call" function and returns the result as a list, prepended with the invocant.

then(string | object | coderef $self, any @args) (any)

{ since => '2.32', }

=example-1 then

package main;

use Venus 'then';

my @list = then('Digest::SHA', 'sha1_hex');

# ("Digest::SHA", "da39a3ee5e6b4b0d3255bfef95601890afd80709")

The throw function builds and returns a Venus::Throw object, or dispatches to the coderef or method provided.

throw(string | hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The true function returns a truthy boolean value which is designed to be practically indistinguishable from the conventional numerical 1 value.

true() (boolean)

{ since => '0.01', }

=example-1 true

package main;

use Venus;

my $true = true;

# 1

The try function builds and returns a Venus::Try object, or dispatches to the coderef or method provided.

try(any $data, string | coderef $code, any @args) (any)

{ since => '2.55', }

The tv function compares the lvalue and rvalue and returns true if they have the same type and value, otherwise returns false. b<Note:> Comparison of coderefs, filehandles, and blessed objects with private state are impossible. This function will only return true if these data types are "identical". It's also impossible to know which blessed objects have private state and therefore could produce false-positives when comparing object in those cases.

tv(any $lvalue, any $rvalue) (boolean)

{ since => '4.15', }

The type function builds and returns a Venus::Type object, or dispatches to the coderef or method provided.

type(string | coderef $code, any @args) (any)

{ since => '4.15', }

The unpack function builds and returns a Venus::Unpack object.

unpack(any @args) (Venus::Unpack)

{ since => '2.40', }

The vars function builds and returns a Venus::Vars object, or dispatches to the coderef or method provided.

vars(hashref $value, string | coderef $code, any @args) (any)

{ since => '2.55', }

The vns function build a Venus package based on the name provided, loads and instantiates the package, and returns an instance of that package or dispatches to the method provided and returns the result.

vns(string $name, args $args, string | coderef $callback, any @args) (any)

{ since => '4.15', }

The what function builds and returns a Venus::What object, or dispatches to the coderef or method provided.

what(any $data, string | coderef $code, any @args) (any)

{ since => '4.11', }

The work function builds a Venus::Process object, forks the current process using the callback provided via the "work" in Venus::Process operation, and returns an instance of Venus::Process representing the current process.

work(coderef $callback) (Venus::Process)

{ since => '2.40', }

The wrap function installs a wrapper function in the calling package which when called either returns the package string if no arguments are provided, or calls "make" on the package with whatever arguments are provided and returns the result. Unless an alias is provided as a second argument, special characters are stripped from the package to create the function name.

wrap(string $data, string $name) (coderef)

{ since => '2.32', }

=example-1 wrap

package main;

use Venus 'wrap';

my $coderef = wrap('Digest::SHA');

# sub { ... }

# my $digest = DigestSHA();

# "Digest::SHA"

# my $digest = DigestSHA(1);

# bless(do{\(my $o = '...')}, 'Digest::SHA')

The write_env function returns a string representing environment variable key/value pairs based on the "value" held by the underlying Venus::Config object.

write_env(hashref $data) (string)

{ since => '4.15', }

The write_env_file function saves a environment configuration file and returns a new Venus::Config object.

write_env_file(string $path, hashref $data) (Venus::Config)

{ since => '4.15', }

=example-1 write_env_file

package main;

use Venus 'write_env_file';

my $write_env_file = write_env_file 't/conf/write.env', {
  APPNAME => "Example",
  APPTAG => "Godzilla",
  APPVER => 0.01,
};

# bless(..., 'Venus::Config')

The write_json function returns a JSON encoded string based on the "value" held by the underlying Venus::Config object.

write_json(hashref $data) (string)

{ since => '4.15', }

=example-1 write_json

package main;

use Venus 'write_json';

my $write_json = write_json {
  '$services' => {
    log => { package => "Venus::Path" },
  },
};

# '{ "$services":{ "log":{ "package":"Venus::Path" } } }'

The write_json_file function saves a JSON configuration file and returns a new Venus::Config object.

write_json_file(string $path, hashref $data) (Venus::Config)

{ since => '4.15', }

=example-1 write_json_file

package main;

use Venus 'write_json_file';

my $write_json_file = write_json_file 't/conf/write.json', {
  '$services' => {
    log => { package => "Venus/Path", argument => { value => "." } }
  }
};

# bless(..., 'Venus::Config')

The write_perl function returns a FILE encoded string based on the "value" held by the underlying Venus::Config object.

write_perl(hashref $data) (string)

{ since => '4.15', }

=example-1 write_perl

package main;

use Venus 'write_perl';

my $write_perl = write_perl {
  '$services' => {
    log => { package => "Venus::Path" },
  },
};

# '{ "\$services" => { log => { package => "Venus::Path" } } }'

The write_perl_file function saves a Perl configuration file and returns a new Venus::Config object.

write_perl_file(string $path, hashref $data) (Venus::Config)

{ since => '4.15', }

=example-1 write_perl_file

package main;

use Venus 'write_perl_file';

my $write_perl_file = write_perl_file 't/conf/write.perl', {
  '$services' => {
    log => { package => "Venus/Path", argument => { value => "." } }
  }
};

# bless(..., 'Venus::Config')

The write_yaml function returns a FILE encoded string based on the "value" held by the underlying Venus::Config object.

write_yaml(hashref $data) (string)

{ since => '4.15', }

=example-1 write_yaml

package main;

use Venus 'write_yaml';

my $write_yaml = write_yaml {
  '$services' => {
    log => { package => "Venus::Path" },
  },
};

# '---\n$services:\n\s\slog:\n\s\s\s\spackage:\sVenus::Path'

The write_yaml_file function saves a YAML configuration file and returns a new Venus::Config object.

write_yaml_file(string $path, hashref $data) (Venus::Config)

{ since => '4.15', }

=example-1 write_yaml_file

package main;

use Venus 'write_yaml_file';

my $write_yaml_file = write_yaml_file 't/conf/write.yaml', {
  '$services' => {
    log => { package => "Venus/Path", argument => { value => "." } }
  }
};

# bless(..., 'Venus::Config')

The yaml function builds a Venus::Yaml object and will either "decode" in Venus::Yaml or "encode" in Venus::Yaml based on the argument provided and returns the result.

yaml(string $call, any $data) (any)

{ since => '2.40', }

This library contains a Venus::Args class which provides methods for accessing @ARGS items.

This library contains a Venus::Array class which provides methods for manipulating array data.

This library contains a Venus::Assert class which provides a mechanism for asserting type constraints and coercion.

This library contains a Venus::Atom class which provides a write-once object representing a constant value.

This library contains a Venus::Boolean class which provides a representation for boolean values.

This library contains a Venus::Box class which provides a pure Perl boxing mechanism.

This library contains a Venus::Call class which provides a protocol for dynamically invoking methods with optional opt-in type safety.

This library contains a Venus::Check class which provides runtime dynamic type checking.

This library contains a Venus::Class class which provides a class builder.

This library contains a Venus::Cli class which provides a superclass for creating CLIs.

This library contains a Venus::Code class which provides methods for manipulating subroutines.

This library contains a Venus::Coercion class which provides data type coercions via Venus::Check.

This library contains a Venus::Collect class which provides a mechanism for iterating over mappable values.

This library contains a Venus::Config class which provides methods for loading Perl, YAML, and JSON configuration data.

This library contains a Venus::Constraint class which provides data type constraints via Venus::Check.

This library contains a Venus::Data class which provides value object for encapsulating data validation.

This library contains a Venus::Date class which provides methods for formatting, parsing, and manipulating dates.

This library contains a Venus::Dump class which provides methods for reading and writing dumped Perl data.

This library contains a Venus::Enum class which provides an interface for working with enumerations.

This library contains a Venus::Error class which represents a context-aware error (exception object).

This library contains a Venus::Factory class which provides an object-oriented factory pattern for building objects.

This library contains a Venus::False class which provides the global false value.

This library contains a Venus::Fault class which represents a generic system error (exception object).

This library contains a Venus::Float class which provides methods for manipulating float data.

This library contains a Venus::Future class which provides a framework-agnostic implementation of the Future pattern.

This library contains a Venus::Gather class which provides an object-oriented interface for complex pattern matching operations on collections of data, e.g. array references.

This library contains a Venus::Hash class which provides methods for manipulating hash data.

This library contains a Venus::Json class which provides methods for reading and writing JSON data.

This library contains a Venus::Log class which provides methods for logging information using various log levels.

This library contains a Venus::Map class which provides a representation of a collection of ordered key/value pairs.

This library contains a Venus::Match class which provides an object-oriented interface for complex pattern matching operations on scalar values.

This library contains a Venus::Meta class which provides configuration information for Venus derived classes.

This library contains a Venus::Mixin class which provides a mixin builder.

This library contains a Venus::Name class which provides methods for parsing and formatting package namespaces.

This library contains a Venus::Number class which provides methods for manipulating number data.

This library contains a Venus::Opts class which provides methods for handling command-line arguments.

This library contains a Venus::Os class which provides methods for determining the current operating system, as well as finding and executing files.

This library contains a Venus::Path class which provides methods for working with file system paths.

This library contains a Venus::Process class which provides methods for handling and forking processes.

This library contains a Venus::Prototype class which provides a simple construct for enabling prototype-base programming.

This library contains a Venus::Random class which provides an object-oriented interface for Perl's pseudo-random number generator.

This library contains a Venus::Range class which provides an object-oriented interface for selecting elements from an arrayref using range expressions.

This library contains a Venus::Regexp class which provides methods for manipulating regexp data.

This library contains a Venus::Replace class which provides methods for manipulating regexp replacement data.

This library contains a Venus::Result class which provides a container for representing success and error states.

This library contains a Venus::Run class which provides a base class for providing a command execution system for creating CLIs (command-line interfaces).

This library contains a Venus::Scalar class which provides methods for manipulating scalar data.

This library contains a Venus::Schema class which provides a mechanism for validating complex data structures.

This library contains a Venus::Sealed class which provides a mechanism for restricting access to the underlying data structure.

This library contains a Venus::Search class which provides methods for manipulating regexp search data.

This library contains a Venus::Set class which provides a representation of a collection of ordered key/value pairs.

This library contains a Venus::Space class which provides methods for parsing and manipulating package namespaces.

This library contains a Venus::String class which provides methods for manipulating string data.

This library contains a Venus::Task class which provides a base class for creating CLIs (command-line interfaces).

This library contains a Venus::Template class which provides a templating system, and methods for rendering template.

This library contains a Venus::Test class which aims to provide a standard for documenting Venus derived software projects.

This library contains a Venus::Text class which provides methods for extracting DATA sections and POD block.

This library contains a Venus::Text::Pod class which provides methods for extracting POD blocks.

This library contains a Venus::Text::Tag class which provides methods for extracting DATA sections.

This library contains a Venus::Throw class which provides a mechanism for generating and raising error objects.

This library contains a Venus::True class which provides the global true value.

This library contains a Venus::Try class which provides an object-oriented interface for performing complex try/catch operations.

This library contains a Venus::Type class which provides a mechanism for parsing, generating, and validating data type expressions.

This library contains a Venus::Undef class which provides methods for manipulating undef data.

This library contains a Venus::Unpack class which provides methods for validating, coercing, and otherwise operating on lists of arguments.

This library contains a Venus::Validate class which provides a mechanism for performing data validation of simple and hierarchal data.

This library contains a Venus::Vars class which provides methods for accessing %ENV items.

This library contains a Venus::What class which provides methods for casting native data types to objects.

This library contains a Venus::Yaml class which provides methods for reading and writing YAML data.

Awncorp, awncorp@cpan.org

Copyright (C) 2022, Awncorp, awncorp@cpan.org.

This program is free software, you can redistribute it and/or modify it under the terms of the Apache license version 2.0.

cpanm Venus

perl -MCPAN -e shell
install Venus