NAME

Earth::Entity - FP Library Functions

ABSTRACT

FP Standard Library Functions for Perl 5

SYNOPSIS

package main;

use Earth;
use Earth::Entity 'Space';

Space;

# "Venus::Space"

DESCRIPTION

This package compliments the Earth functional-programming framework by providing wrapper functions, via "wrap" in Earth, which wrap Venus classes, providing a functional abstraction around the Venus object-oriented standard library.

FUNCTIONS

This package provides the following functions:

args

Args(HashRef $data) (Str | Object)

The Args function dispatches function and method calls to Venus::Args.

Since 0.01

Args example 1

package main;

use Earth;
use Earth::Entity 'Args';

my $string = Args();

# "Venus::Args"

Args example 2

package main;

use Earth;
use Earth::Entity 'Args';

my $string = Args({});

# bless( {...}, "Venus::Args" )

array

Array(HashRef $data) (Str | Object)

The Array function dispatches function and method calls to Venus::Array.

Since 0.01

Array example 1

package main;

use Earth;
use Earth::Entity 'Array';

my $string = Array();

# "Venus::Array"

Array example 2

package main;

use Earth;
use Earth::Entity 'Array';

my $string = Array({});

# bless( {...}, "Venus::Array" )

boolean

Boolean(HashRef $data) (Str | Object)

The Boolean function dispatches function and method calls to Venus::Boolean.

Since 0.01

Boolean example 1

package main;

use Earth;
use Earth::Entity 'Boolean';

my $string = Boolean();

# "Venus::Boolean"

Boolean example 2

package main;

use Earth;
use Earth::Entity 'Boolean';

my $string = Boolean({});

# bless( {...}, "Venus::Boolean" )

code

Code(HashRef $data) (Str | Object)

The Code function dispatches function and method calls to Venus::Code.

Since 0.01

Code example 1

package main;

use Earth;
use Earth::Entity 'Code';

my $string = Code();

# "Venus::Code"

Code example 2

package main;

use Earth;
use Earth::Entity 'Code';

my $string = Code({});

# bless( {...}, "Venus::Code" )

data

Data(HashRef $data) (Str | Object)

The Data function dispatches function and method calls to Venus::Data.

Since 0.01

Data example 1

package main;

use Earth;
use Earth::Entity 'Data';

my $string = Data();

# "Venus::Data"

Data example 2

package main;

use Earth;
use Earth::Entity 'Data';

my $string = Data({});

# bless( {...}, "Venus::Data" )

date

Date(HashRef $data) (Str | Object)

The Date function dispatches function and method calls to Venus::Date.

Since 0.01

Date example 1

package main;

use Earth;
use Earth::Entity 'Date';

my $string = Date();

# "Venus::Date"

Date example 2

package main;

use Earth;
use Earth::Entity 'Date';

my $string = Date({});

# bless( {...}, "Venus::Date" )

error

Error(HashRef $data) (Str | Object)

The Error function dispatches function and method calls to Venus::Error.

Since 0.01

Error example 1

package main;

use Earth;
use Earth::Entity 'Error';

my $string = Error();

# "Venus::Error"

Error example 2

package main;

use Earth;
use Earth::Entity 'Error';

my $string = Error({});

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

float

Float(HashRef $data) (Str | Object)

The Float function dispatches function and method calls to Venus::Float.

Since 0.01

Float example 1

package main;

use Earth;
use Earth::Entity 'Float';

my $string = Float();

# "Venus::Float"

Float example 2

package main;

use Earth;
use Earth::Entity 'Float';

my $string = Float({});

# bless( {...}, "Venus::Float" )

hash

Hash(HashRef $data) (Str | Object)

The Hash function dispatches function and method calls to Venus::Hash.

Since 0.01

Hash example 1

package main;

use Earth;
use Earth::Entity 'Hash';

my $string = Hash();

# "Venus::Hash"

Hash example 2

package main;

use Earth;
use Earth::Entity 'Hash';

my $string = Hash({});

# bless( {...}, "Venus::Hash" )

json

Json(HashRef $data) (Str | Object)

The Json function dispatches function and method calls to Venus::Json.

Since 0.01

Json example 1

package main;

use Earth;
use Earth::Entity 'Json';

my $string = Json();

# "Venus::Json"

Json example 2

package main;

use Earth;
use Earth::Entity 'Json';

my $string = Json({});

# bless( {...}, "Venus::Json" )

match

Match(HashRef $data) (Str | Object)

The Match function dispatches function and method calls to Venus::Match.

Since 0.01

Match example 1

package main;

use Earth;
use Earth::Entity 'Match';

my $string = Match();

# "Venus::Match"

Match example 2

package main;

use Earth;
use Earth::Entity 'Match';

my $string = Match({});

# bless( {...}, "Venus::Match" )

name

Name(HashRef $data) (Str | Object)

The Name function dispatches function and method calls to Venus::Name.

Since 0.01

Name example 1

package main;

use Earth;
use Earth::Entity 'Name';

my $string = Name();

# "Venus::Name"

Name example 2

package main;

use Earth;
use Earth::Entity 'Name';

my $string = Name({});

# bless( {...}, "Venus::Name" )

number

Number(HashRef $data) (Str | Object)

The Number function dispatches function and method calls to Venus::Number.

Since 0.01

Number example 1

package main;

use Earth;
use Earth::Entity 'Number';

my $string = Number();

# "Venus::Number"

Number example 2

package main;

use Earth;
use Earth::Entity 'Number';

my $string = Number({});

# bless( {...}, "Venus::Number" )

opts

Opts(HashRef $data) (Str | Object)

The Opts function dispatches function and method calls to Venus::Opts.

Since 0.01

Opts example 1

package main;

use Earth;
use Earth::Entity 'Opts';

my $string = Opts();

# "Venus::Opts"

Opts example 2

package main;

use Earth;
use Earth::Entity 'Opts';

my $string = Opts({});

# bless( {...}, "Venus::Opts" )

path

Path(HashRef $data) (Str | Object)

The Path function dispatches function and method calls to Venus::Path.

Since 0.01

Path example 1

package main;

use Earth;
use Earth::Entity 'Path';

my $string = Path();

# "Venus::Path"

Path example 2

package main;

use Earth;
use Earth::Entity 'Path';

my $string = Path({});

# bless( {...}, "Venus::Path" )

process

Process(HashRef $data) (Str | Object)

The Process function dispatches function and method calls to Venus::Process.

Since 0.01

Process example 1

package main;

use Earth;
use Earth::Entity 'Process';

my $string = Process();

# "Venus::Process"

Process example 2

package main;

use Earth;
use Earth::Entity 'Process';

my $string = Process({});

# bless( {...}, "Venus::Process" )

regexp

Regexp(HashRef $data) (Str | Object)

The Regexp function dispatches function and method calls to Venus::Regexp.

Since 0.01

Regexp example 1

package main;

use Earth;
use Earth::Entity 'Regexp';

my $string = Regexp();

# "Venus::Regexp"

Regexp example 2

package main;

use Earth;
use Earth::Entity 'Regexp';

my $string = Regexp({});

# bless( {...}, "Venus::Regexp" )

replace

Replace(HashRef $data) (Str | Object)

The Replace function dispatches function and method calls to Venus::Replace.

Since 0.01

Replace example 1

package main;

use Earth;
use Earth::Entity 'Replace';

my $string = Replace();

# "Venus::Replace"

Replace example 2

package main;

use Earth;
use Earth::Entity 'Replace';

my $string = Replace({});

# bless( {...}, "Venus::Replace" )

scalar

Scalar(HashRef $data) (Str | Object)

The Scalar function dispatches function and method calls to Venus::Scalar.

Since 0.01

Scalar example 1

package main;

use Earth;
use Earth::Entity 'Scalar';

my $string = Scalar();

# "Venus::Scalar"

Scalar example 2

package main;

use Earth;
use Earth::Entity 'Scalar';

my $string = Scalar({});

# bless( {...}, "Venus::Scalar" )

search

Search(HashRef $data) (Str | Object)

The Search function dispatches function and method calls to Venus::Search.

Since 0.01

Search example 1

package main;

use Earth;
use Earth::Entity 'Search';

my $string = Search();

# "Venus::Search"

Search example 2

package main;

use Earth;
use Earth::Entity 'Search';

my $string = Search({});

# bless( {...}, "Venus::Search" )

space

Space(HashRef $data) (Str | Object)

The Space function dispatches function and method calls to Venus::Space.

Since 0.01

Space example 1

package main;

use Earth;
use Earth::Entity 'Space';

my $string = Space();

# "Venus::Space"

Space example 2

package main;

use Earth;
use Earth::Entity 'Space';

my $string = Space({});

# bless( {...}, "Venus::Space" )

string

String(HashRef $data) (Str | Object)

The String function dispatches function and method calls to Venus::String.

Since 0.01

String example 1

package main;

use Earth;
use Earth::Entity 'String';

my $string = String();

# "Venus::String"

String example 2

package main;

use Earth;
use Earth::Entity 'String';

my $string = String({});

# bless( {...}, "Venus::String" )

template

Template(HashRef $data) (Str | Object)

The Template function dispatches function and method calls to Venus::Template.

Since 0.01

Template example 1

package main;

use Earth;
use Earth::Entity 'Template';

my $string = Template();

# "Venus::Template"

Template example 2

package main;

use Earth;
use Earth::Entity 'Template';

my $string = Template({});

# bless( {...}, "Venus::Template" )

throw

Throw(HashRef $data) (Str | Object)

The Throw function dispatches function and method calls to Venus::Throw.

Since 0.01

Throw example 1

package main;

use Earth;
use Earth::Entity 'Throw';

my $string = Throw();

# "Venus::Throw"

Throw example 2

package main;

use Earth;
use Earth::Entity 'Throw';

my $string = Throw({});

# bless( {...}, "Venus::Throw" )

try

Try(HashRef $data) (Str | Object)

The Try function dispatches function and method calls to Venus::Try.

Since 0.01

Try example 1

package main;

use Earth;
use Earth::Entity 'Try';

my $string = Try();

# "Venus::Try"

Try example 2

package main;

use Earth;
use Earth::Entity 'Try';

my $string = Try({});

# bless( {...}, "Venus::Try" )

type

Type(HashRef $data) (Str | Object)

The Type function dispatches function and method calls to Venus::Type.

Since 0.01

Type example 1

package main;

use Earth;
use Earth::Entity 'Type';

my $string = Type();

# "Venus::Type"

Type example 2

package main;

use Earth;
use Earth::Entity 'Type';

my $string = Type({});

# bless( {...}, "Venus::Type" )

undef

Undef(HashRef $data) (Str | Object)

The Undef function dispatches function and method calls to Venus::Undef.

Since 0.01

Undef example 1

package main;

use Earth;
use Earth::Entity 'Undef';

my $string = Undef();

# "Venus::Undef"

Undef example 2

package main;

use Earth;
use Earth::Entity 'Undef';

my $string = Undef({});

# bless( {...}, "Venus::Undef" )

vars

Vars(HashRef $data) (Str | Object)

The Vars function dispatches function and method calls to Venus::Vars.

Since 0.01

Vars example 1

package main;

use Earth;
use Earth::Entity 'Vars';

my $string = Vars();

# "Venus::Vars"

Vars example 2

package main;

use Earth;
use Earth::Entity 'Vars';

my $string = Vars({});

# bless( {...}, "Venus::Vars" )

yaml

Yaml(HashRef $data) (Str | Object)

The Yaml function dispatches function and method calls to Venus::Yaml.

Since 0.01

Yaml example 1

package main;

use Earth;
use Earth::Entity 'Yaml';

my $string = Yaml();

# "Venus::Yaml"

Yaml example 2

package main;

use Earth;
use Earth::Entity 'Yaml';

my $string = Yaml({});

# bless( {...}, "Venus::Yaml" )

AUTHORS

Awncorp, awncorp@cpan.org

cpanm Earth

perl -MCPAN -e shell
install Earth