The London Perl and Raku Workshop takes place on 26th Oct 2024. If your company depends on Perl, please consider sponsoring and/or attending.
 / 
Earth-0.01
River stage zero No dependents
/ Earth::Entity

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(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