Venus::Code - Code Class
Code Class for Perl 5
package main; use Venus::Code; my $code = Venus::Code->new(sub { my (@args) = @_; return [@args]; }); # $code->call(1..4);
This package provides methods for manipulating code data.
This package inherits behaviors from:
Venus::Kind::Value
This package provides the following methods:
call(Any @data) (Any)
The call method executes and returns the result of the code.
Since 0.01
0.01
package main; use Venus::Code; my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 }); my $call = $code->call; # 1
package main; use Venus::Code; my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 }); my $call = $code->call(1); # 2
package main; use Venus::Code; my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 }); my $call = $code->call(2); # 3
cast(Str $kind) (Object | Undef)
The cast method converts "value" objects between different "value" object types, based on the name of the type provided. This method will return undef if the invocant is not a Venus::Kind::Value.
undef
Since 0.08
0.08
package main; use Venus::Code; my $code = Venus::Code->new(sub{[@_]}); my $cast = $code->cast('array'); # bless({ value => [sub { ... }] }, "Venus::Array")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('boolean'); # bless({ value => 1 }, "Venus::Boolean")
package main; use Venus::Code; my $code = Venus::Code->new(sub{[@_]}); my $cast = $code->cast('code'); # bless({ value => sub { ... } }, "Venus::Code")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('float'); # bless({ value => "1.0" }, "Venus::Float")
package main; use Venus::Code; my $code = Venus::Code->new(sub{[@_]}); my $cast = $code->cast('hash'); # bless({ value => { "0" => sub { ... } } }, "Venus::Hash")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('number'); # bless({ value => 112 }, "Venus::Number")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('regexp'); # bless({ value => qr/.../, }, "Venus::Regexp")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('scalar'); # bless({ value => \sub {...} }, "Venus::Scalar")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('string'); # bless({ value => "sub {...}" }, "Venus::String")
package main; use Venus::Code; my $code = Venus::Code->new; my $cast = $code->cast('undef'); # bless({ value => undef }, "Venus::Undef")
compose(CodeRef $code, Any @data) (CodeRef)
The compose method creates a code reference which executes the first argument (another code reference) using the result from executing the code as it's argument, and returns a code reference which executes the created code reference passing it the remaining arguments when executed.
package main; use Venus::Code; my $code = Venus::Code->new(sub { [@_] }); my $compose = $code->compose($code, 1, 2, 3); # sub { ... } # $compose->(4, 5, 6); # [[1,2,3,4,5,6]]
conjoin(CodeRef $code) (CodeRef)
The conjoin method creates a code reference which execute the code and the argument in a logical AND operation having the code as the lvalue and the argument as the rvalue.
package main; use Venus::Code; my $code = Venus::Code->new(sub { $_[0] % 2 }); my $conjoin = $code->conjoin(sub { 1 }); # sub { ... } # $conjoin->(0); # 0 # $conjoin->(1); # 1 # $conjoin->(2); # 0 # $conjoin->(3); # 1 # $conjoin->(4); # 0
curry(Any @data) (CodeRef)
The curry method returns a code reference which executes the code passing it the arguments and any additional parameters when executed.
package main; use Venus::Code; my $code = Venus::Code->new(sub { [@_] }); my $curry = $code->curry(1, 2, 3); # sub { ... } # $curry->(4,5,6); # [1,2,3,4,5,6]
default() (CodeRef)
The default method returns the default value, i.e. sub{}.
sub{}
# given: synopsis; my $default = $code->default; # sub {}
disjoin(CodeRef $code) (CodeRef)
The disjoin method creates a code reference which execute the code and the argument in a logical OR operation having the code as the lvalue and the argument as the rvalue.
package main; use Venus::Code; my $code = Venus::Code->new(sub { $_[0] % 2 }); my $disjoin = $code->disjoin(sub { -1 }); # sub { ... } # disjoin->(0); # -1 # disjoin->(1); # 1 # disjoin->(2); # -1 # disjoin->(3); # 1 # disjoin->(4); # -1
eq(Any $arg) (Bool)
The eq method performs an "equals" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->eq($rvalue); # 0
ge(Any $arg) (Bool)
The ge method performs a "greater-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ge($rvalue); # 1
gele(Any $arg1, Any $arg2) (Bool)
The gele method performs a "greater-than-or-equal-to" operation on the 1st argument, and "lesser-than-or-equal-to" operation on the 2nd argument.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gele($rvalue); # 0
gt(Any $arg) (Bool)
The gt method performs a "greater-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gt($rvalue); # 1
gtlt(Any $arg1, Any $arg2) (Bool)
The gtlt method performs a "greater-than" operation on the 1st argument, and "lesser-than" operation on the 2nd argument.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gtlt($rvalue); # 0
le(Any $arg) (Bool)
The le method performs a "lesser-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->le($rvalue); # 0
lt(Any $arg) (Bool)
The lt method performs a "lesser-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->lt($rvalue); # 0
ne(Any $arg) (Bool)
The ne method performs a "not-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ne($rvalue); # 1
next(Any @data) (Any)
The next method is an alias to the call method. The naming is especially useful (i.e. helps with readability) when used with closure-based iterators.
package main; use Venus::Code; my $code = Venus::Code->new(sub { $_[0] * 2 }); my $next = $code->next(72); # 144
rcurry(Any @data) (CodeRef)
The rcurry method returns a code reference which executes the code passing it the any additional parameters and any arguments when executed.
package main; use Venus::Code; my $code = Venus::Code->new(sub { [@_] }); my $rcurry = $code->rcurry(1,2,3); # sub { ... } # $rcurry->(4,5,6); # [4,5,6,1,2,3]
tv(Any $arg) (Bool)
The tv method performs a "type-and-value-equal-to" operation using argument provided.
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Array->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; my $lvalue = Venus::Code->new; my $rvalue = Venus::Code->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::Code; use Venus::Float; my $lvalue = Venus::Code->new; my $rvalue = Venus::Float->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Code->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Number; my $lvalue = Venus::Code->new; my $rvalue = Venus::Number->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Regexp; my $lvalue = Venus::Code->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Scalar; my $lvalue = Venus::Code->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::String; my $lvalue = Venus::Code->new; my $rvalue = Venus::String->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Undef; my $lvalue = Venus::Code->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->tv($rvalue); # 0
This package overloads the following operators:
(&{})
This package overloads the &{} operator.
&{}
example 1
# given: synopsis; my $result = &$code(1..4); # [1..4]
To install Venus, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Venus
CPAN shell
perl -MCPAN -e shell install Venus
For more information on module installation, please visit the detailed CPAN module installation guide.