Venus::Hash - Hash Class
Hash Class for Perl 5
package main; use Venus::Hash; my $hash = Venus::Hash->new({1..8}); # $hash->random;
This package provides methods for manipulating hash data.
This package inherits behaviors from:
Venus::Kind::Value
This package integrates behaviors from:
Venus::Role::Mappable
This package provides the following methods:
all(CodeRef $code) (Bool)
The all method returns true if the callback returns true for all of the elements.
Since 0.01
0.01
# given: synopsis; my $all = $hash->all(sub { $_ > 1 }); # 1
# given: synopsis; my $all = $hash->all(sub { my ($key, $value) = @_; $value > 1 }); # 1
any(CodeRef $code) (Bool)
The any method returns true if the callback returns true for any of the elements.
# given: synopsis; my $any = $hash->any(sub { $_ < 1 }); # 0
# given: synopsis; my $any = $hash->any(sub { my ($key, $value) = @_; $value < 1 }); # 0
call(Str $iterable, Str $method) (Any)
The call method executes the given method (named using the first argument) which performs an iteration (i.e. takes a callback) and calls the method (named using the second argument) on the object (or value) and returns the result of the iterable method.
Since 1.02
1.02
# given: synopsis package main; my $call = $hash->call('map', 'incr'); # ['1', 3, '3', 5, '5', 7, '7', 9]
# given: synopsis package main; my $call = $hash->call('grep', 'gt', 4); # [5..8]
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::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('array'); # bless({ value => [{}] }, "Venus::Array")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('boolean'); # bless({ value => 1 }, "Venus::Boolean")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('code'); # bless({ value => sub { ... } }, "Venus::Code")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('float'); # bless({ value => "1.0" }, "Venus::Float")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('hash'); # bless({ value => {} }, "Venus::Hash")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('number'); # bless({ value => 2 }, "Venus::Number")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('regexp'); # bless({ value => qr/(?^u:\{\})/ }, "Venus::Regexp")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('scalar'); # bless({ value => \{} }, "Venus::Scalar")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('string'); # bless({ value => "{}" }, "Venus::String")
package main; use Venus::Hash; my $hash = Venus::Hash->new; my $cast = $hash->cast('undef'); # bless({ value => undef }, "Venus::Undef")
count() (Int)
The count method returns the total number of keys defined.
# given: synopsis; my $count = $hash->count; # 4
default() (HashRef)
The default method returns the default value, i.e. {}.
{}
# given: synopsis; my $default = $hash->default; # {}
delete(Str $key) (Any)
The delete method returns the value matching the key specified in the argument and returns the value.
# given: synopsis; my $delete = $hash->delete(1); # 2
each(CodeRef $code) (ArrayRef)
The each method executes callback for each element in the hash passing the routine the key and value at the current position in the loop. This method can return a list of values in list-context.
# given: synopsis; my $each = $hash->each(sub { [$_] }); # [[2], [4], [6], [8]]
# given: synopsis; my $each = $hash->each(sub { my ($key, $value) = @_; [$key, $value] }); # [[1, 2], [3, 4], [5, 6], [7, 8]]
empty() (HashRef)
The empty method drops all elements from the hash.
# given: synopsis; my $empty = $hash->empty; # {}
eq(Any $arg) (Bool)
The eq method performs an "equals" operation using the argument provided.
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->eq($rvalue); # 0
exists(Str $key) (Bool)
The exists method returns true if the value matching the key specified in the argument exists, otherwise returns false.
# given: synopsis; my $exists = $hash->exists(1); # 1
# given: synopsis; my $exists = $hash->exists(0); # 0
find(Str @data) (Any)
The find method traverses the data structure using the keys and indices provided, returning the value found or undef. In list-context, this method returns a tuple, i.e. the value found and boolean representing whether the match was successful.
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $find = $hash->find('foo', 'bar'); # "baz"
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $find = $hash->find('bar', 0); # "baz"
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $find = $hash->find('bar'); # ["baz"]
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my ($find, $exists) = $hash->find('baz'); # (undef, 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::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->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::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gele($rvalue); # 0
grep(CodeRef $code) (ArrayRef)
The grep method executes callback for each key/value pair in the hash passing the routine the key and value at the current position in the loop and returning a new hash reference containing the elements for which the argument evaluated true. This method can return a list of values in list-context.
# given: synopsis; my $grep = $hash->grep(sub { $_ >= 3 }); # [3..8]
# given: synopsis; my $grep = $hash->grep(sub { my ($key, $value) = @_; $value >= 3 }); # [3..8]
gt(Any $arg) (Bool)
The gt method performs a "greater-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->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::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gtlt($rvalue); # 0
iterator() (CodeRef)
The iterator method returns a code reference which can be used to iterate over the hash. Each time the iterator is executed it will return the values of the next element in the hash until all elements have been seen, at which point the iterator will return an undefined value. This method can return a tuple with the key and value in list-context.
# given: synopsis; my $iterator = $hash->iterator; # sub { ... } # while (my $value = $iterator->()) { # say $value; # 1 # }
# given: synopsis; my $iterator = $hash->iterator; # sub { ... } # while (grep defined, my ($key, $value) = $iterator->()) { # say $value; # 1 # }
keys() (ArrayRef)
The keys method returns an array reference consisting of all the keys in the hash.
# given: synopsis; my $keys = $hash->keys; # [1, 3, 5, 7]
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::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->le($rvalue); # 0
length() (Int)
The length method returns the total number of keys defined, and is an alias for the "count" method.
# given: synopsis; my $length = $hash->length; # 4
list() (Any)
The list method returns a shallow copy of the underlying hash reference as an array reference.
# given: synopsis; my $list = $hash->list; # 4
# given: synopsis; my @list = $hash->list; # (1..8)
lt(Any $arg) (Bool)
The lt method performs a "lesser-than" operation using the argument provided.
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->lt($rvalue); # 0
map(CodeRef $code) (ArrayRef)
The map method executes callback for each key/value in the hash passing the routine the value at the current position in the loop and returning a new hash reference containing the elements for which the argument returns a value or non-empty list. This method can return a list of values in list-context.
# given: synopsis; my $map = $hash->map(sub { $_ * 2 }); # [4, 8, 12, 16]
# given: synopsis; my $map = $hash->map(sub { my ($key, $value) = @_; [$key, ($value * 2)] }); # [[1, 4], [3, 8], [5, 12], [7, 16]]
merge(HashRef @data) (HashRef)
The merge method returns a hash reference where the elements in the hash and the elements in the argument(s) are merged. This operation performs a deep merge and clones the datasets to ensure no side-effects. The merge behavior merges hash references only, all other data types are assigned with precendence given to the value being merged.
# given: synopsis; my $merge = $hash->merge({1 => 'a'}); # { 1 => "a", 3 => 4, 5 => 6, 7 => 8 }
# given: synopsis; my $merge = $hash->merge({1 => 'a'}, {5 => 'b'}); # { 1 => "a", 3 => 4, 5 => "b", 7 => 8 }
ne(Any $arg) (Bool)
The ne method performs a "not-equal-to" operation using the argument provided.
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->ne($rvalue); # 1
none(CodeRef $code) (Bool)
The none method returns true if none of the elements in the array meet the criteria set by the operand and rvalue.
# given: synopsis; my $none = $hash->none(sub { $_ < 1 }); # 1
# given: synopsis; my $none = $hash->none(sub { my ($key, $value) = @_; $value < 1 }); # 1
one(CodeRef $code) (Bool)
The one method returns true if only one of the elements in the array meet the criteria set by the operand and rvalue.
# given: synopsis; my $one = $hash->one(sub { $_ == 2 }); # 1
# given: synopsis; my $one = $hash->one(sub { my ($key, $value) = @_; $value == 2 }); # 1
pairs() (ArrayRef)
The pairs method is an alias to the pairs_array method. This method can return a list of values in list-context.
# given: synopsis; my $pairs = $hash->pairs; # [[1, 2], [3, 4], [5, 6], [7, 8]]
path(Str $expr) (Any)
The path method traverses the data structure using the path expr provided, returning the value found or undef. In list-context, this method returns a tuple, i.e. the value found and boolean representing whether the match was successful.
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $path = $hash->path('/foo/bar'); # "baz"
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $path = $hash->path('/bar/0'); # "baz"
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my $path = $hash->path('/bar'); # ["baz"]
package main; use Venus::Hash; my $hash = Venus::Hash->new({'foo' => {'bar' => 'baz'},'bar' => ['baz']}); my ($path, $exists) = $hash->path('/baz'); # (undef, 0)
random() (Any)
The random method returns a random element from the array.
# given: synopsis; my $random = $hash->random; # 6 # my $random = $hash->random; # 4
reset() (ArrayRef)
The reset method returns nullifies the value of each element in the hash.
# given: synopsis; my $reset = $hash->reset; # { 1 => undef, 3 => undef, 5 => undef, 7 => undef }
reverse() (HashRef)
The reverse method returns a hash reference consisting of the hash's keys and values inverted. Note, keys with undefined values will be dropped.
# given: synopsis; my $reverse = $hash->reverse; # { 2 => 1, 4 => 3, 6 => 5, 8 => 7 }
slice(Str @keys) (ArrayRef)
The slice method returns an array reference of the values that correspond to the key(s) specified in the arguments.
# given: synopsis; my $slice = $hash->slice(1, 3); # [2, 4]
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::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Array->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Code; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Code->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Float; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Float->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::Hash; use Venus::Number; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Number->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; use Venus::Regexp; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; use Venus::Scalar; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; use Venus::String; my $lvalue = Venus::Hash->new; my $rvalue = Venus::String->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Hash; use Venus::Undef; my $lvalue = Venus::Hash->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->tv($rvalue); # 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.