NAME

Venus::Code - Code Class

ABSTRACT

Code Class for Perl 5

SYNOPSIS


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub {
  my (@args) = @_;
  return [@args];
});
# $code->call(1..4);

DESCRIPTION

This package provides methods for manipulating subroutines.

INHERITS

This package inherits behaviors from:

Venus::Kind::Value

METHODS

This package provides the following methods:

call


            
              
              call(any @data) (any)

The call method executes and returns the result of the code.

Since 0.01

call example 1


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
my $call = $code->call;
# 1

call example 2


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
my $call = $code->call(1);
# 2

call example 3


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub { ($_[0] // 0) + 1 });
my $call = $code->call(2);
# 3

cast


            
              
              cast(string $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.

Since 0.08

cast example 1


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub{[@_]});
my $cast = $code->cast('array');
# bless({ value => [sub { ... }] }, "Venus::Array")

cast example 2


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('boolean');
# bless({ value => 1 }, "Venus::Boolean")

cast example 3


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub{[@_]});
my $cast = $code->cast('code');
# bless({ value => sub { ... } }, "Venus::Code")

cast example 4


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('float');
# bless({ value => "1.0" }, "Venus::Float")

cast example 5


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub{[@_]});
my $cast = $code->cast('hash');
# bless({ value => { "0" => sub { ... } } }, "Venus::Hash")

cast example 6


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('number');
# bless({ value => 112 }, "Venus::Number")

cast example 7


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('regexp');
# bless({ value => qr/.../, }, "Venus::Regexp")

cast example 8


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('scalar');
# bless({ value => \sub {...} }, "Venus::Scalar")

cast example 9


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('string');
# bless({ value => "sub {...}" }, "Venus::String")

cast example 10


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new;
my $cast = $code->cast('undef');
# bless({ value => undef }, "Venus::Undef")

compose


            
              
              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.

Since 0.01

compose example 1


            
              
              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


            
              
              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.

Since 0.01

conjoin example 1


            
              
              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


            
              
              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.

Since 0.01

curry example 1


            
              
              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


            
              
              default() (coderef)

The default method returns the default value, i.e. sub{}.

Since 0.01

default example 1


            
              
              # given: synopsis;
my $default = $code->default;
# sub {}

disjoin


            
              
              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.

Since 0.01

disjoin example 1


            
              
              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


            
              
              eq(any $arg) (boolean)

The eq method performs an "equals" operation using the argument provided.

Since 0.08

eq example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->eq($rvalue);
# 1

eq example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->eq($rvalue);
# 0

eq example 9


            
              
              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


            
              
              ge(any $arg) (boolean)

The ge method performs a "greater-than-or-equal-to" operation using the argument provided.

Since 0.08

ge example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->ge($rvalue);
# 1

ge example 9


            
              
              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


            
              
              gele(any $arg1, any $arg2) (boolean)

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.

Since 0.08

gele example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->gele($rvalue);
# 0

gele example 9


            
              
              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


            
              
              gt(any $arg) (boolean)

The gt method performs a "greater-than" operation using the argument provided.

Since 0.08

gt example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->gt($rvalue);
# 0

gt example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->gt($rvalue);
# 1

gt example 9


            
              
              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


            
              
              gtlt(any $arg1, any $arg2) (boolean)

The gtlt method performs a "greater-than" operation on the 1st argument, and "lesser-than" operation on the 2nd argument.

Since 0.08

gtlt example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->gtlt($rvalue);
# 0

gtlt example 9


            
              
              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


            
              
              le(any $arg) (boolean)

The le method performs a "lesser-than-or-equal-to" operation using the argument provided.

Since 0.08

le example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->le($rvalue);
# 0

le example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->le($rvalue);
# 1

le example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->le($rvalue);
# 0

le example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->le($rvalue);
# 0

le example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->le($rvalue);
# 0

le example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->le($rvalue);
# 0

le example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->le($rvalue);
# 0

le example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->le($rvalue);
# 0

le example 9


            
              
              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


            
              
              lt(any $arg) (boolean)

The lt method performs a "lesser-than" operation using the argument provided.

Since 0.08

lt example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->lt($rvalue);
# 0

lt example 9


            
              
              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


            
              
              ne(any $arg) (boolean)

The ne method performs a "not-equal-to" operation using the argument provided.

Since 0.08

ne example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->ne($rvalue);
# 0

ne example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->ne($rvalue);
# 1

ne example 9


            
              
              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.

Since 0.01

next example 1


            
              
              package main;
use Venus::Code;
my $code = Venus::Code->new(sub { $_[0] * 2 });
my $next = $code->next(72);
# 144

rcurry


            
              
              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.

Since 0.01

rcurry example 1


            
              
              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


            
              
              tv(any $arg) (boolean)

The tv method performs a "type-and-value-equal-to" operation using argument provided.

Since 0.08

tv example 1


            
              
              package main;
use Venus::Array;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Array->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 2


            
              
              package main;
use Venus::Code;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Code->new;
my $result = $lvalue->tv($rvalue);
# 1

tv example 3


            
              
              package main;
use Venus::Code;
use Venus::Float;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Float->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 4


            
              
              package main;
use Venus::Code;
use Venus::Hash;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Hash->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 5


            
              
              package main;
use Venus::Code;
use Venus::Number;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Number->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 6


            
              
              package main;
use Venus::Code;
use Venus::Regexp;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Regexp->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 7


            
              
              package main;
use Venus::Code;
use Venus::Scalar;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Scalar->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 8


            
              
              package main;
use Venus::Code;
use Venus::String;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::String->new;
my $result = $lvalue->tv($rvalue);
# 0

tv example 9


            
              
              package main;
use Venus::Code;
use Venus::Undef;
my $lvalue = Venus::Code->new;
my $rvalue = Venus::Undef->new;
my $result = $lvalue->tv($rvalue);
# 0

OPERATORS

This package overloads the following operators:

operation: (&{})

This package overloads the &{} operator.

example 1


            
              
              # given: synopsis;
my $result = &$code(1..4);
# [1..4]

AUTHORS

Awncorp, awncorp@cpan.org

LICENSE

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

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.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

ABSTRACT

SYNOPSIS

DESCRIPTION

INHERITS

METHODS

call

cast

compose

conjoin

curry

default

disjoin

eq

ge

gele

gt

gtlt

le

lt

ne

next

rcurry

tv

OPERATORS

AUTHORS

LICENSE

Module Install Instructions