Venus::Array - Array Class
Array Class for Perl 5
package main; use Venus::Array; my $array = Venus::Array->new([1..9]); # $array->random;
This package provides methods for manipulating array 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 = $array->all(sub { $_ > 0; }); # 1
# given: synopsis; my $all = $array->all(sub { my ($key, $value) = @_; $value > 0; }); # 1
any(CodeRef $code) (Bool)
The any method returns true if the callback returns true for any of the elements.
# given: synopsis; my $any = $array->any(sub { $_ > 4; });
# given: synopsis; my $any = $array->any(sub { my ($key, $value) = @_; $value > 4; });
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 = $array->call('map', 'incr'); # [2..10]
# given: synopsis package main; my $call = $array->call('grep', 'gt', 4); # [4..9]
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::Array; my $array = Venus::Array->new; my $cast = $array->cast('array'); # bless({ value => [] }, "Venus::Array")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('boolean'); # bless({ value => 1 }, "Venus::Boolean")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('code'); # bless({ value => sub { ... } }, "Venus::Code")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('float'); # bless({ value => "1.0" }, "Venus::Float")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('hash'); # bless({ value => {} }, "Venus::Hash")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('number'); # bless({ value => 2 }, "Venus::Number")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('regexp'); # bless({ value => qr/(?^u:\[\])/ }, "Venus::Regexp")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('scalar'); # bless({ value => \[] }, "Venus::Scalar")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('string'); # bless({ value => "[]" }, "Venus::String")
package main; use Venus::Array; my $array = Venus::Array->new; my $cast = $array->cast('undef'); # bless({ value => undef }, "Venus::Undef")
count() (Int)
The count method returns the number of elements within the array.
# given: synopsis; my $count = $array->count; # 9
default() (ArrayRef)
The default method returns the default value, i.e. [].
[]
# given: synopsis; my $default = $array->default; # []
delete(Int $index) (Any)
The delete method returns the value of the element at the index specified after removing it from the array.
# given: synopsis; my $delete = $array->delete(2); # 3
each(CodeRef $code) (ArrayRef)
The each method executes a callback for each element in the array passing the index and value as arguments. This method can return a list of values in list-context.
# given: synopsis; my $each = $array->each(sub { [$_] }); # [[1], [2], [3], [4], [5], [6], [7], [8], [9]]
# given: synopsis; my $each = $array->each(sub { my ($key, $value) = @_; [$key, $value] }); # [ # [0, 1], # [1, 2], # [2, 3], # [3, 4], # [4, 5], # [5, 6], # [6, 7], # [7, 8], # [8, 9], # ]
empty() (Array)
The empty method drops all elements from the array.
# given: synopsis; my $empty = $array->empty; # bless({ value => [] }, "Venus::Array")
eq(Any $arg) (Bool)
The eq method performs an "equals" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->eq($rvalue); # 1
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->eq($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->eq($rvalue); # 0
exists(Int $index) (Bool)
The exists method returns true if the element at the index specified exists, otherwise it returns false.
# given: synopsis; my $exists = $array->exists(0); # 1
find(Str @keys) (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::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $find = $array->find(0, 'foo'); # { bar => "baz" }
package main; use Venus::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $find = $array->find(0, 'foo', 'bar'); # "baz"
package main; use Venus::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $find = $array->find(2, 0); # "baz"
first() (Any)
The first method returns the value of the first element.
# given: synopsis; my $first = $array->first; # 1
ge(Any $arg) (Bool)
The ge method performs a "greater-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ge($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->ge($rvalue); # 1
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->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; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->gele($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->gele($rvalue); # 0
grep(CodeRef $code) (ArrayRef)
The grep method executes a callback for each element in the array passing the value as an argument, returning a new array reference containing the elements for which the returned true. This method can return a list of values in list-context.
# given: synopsis; my $grep = $array->grep(sub { $_ > 3 }); # [4..9]
# given: synopsis; my $grep = $array->grep(sub { my ($key, $value) = @_; $value > 3 }); # [4..9]
gt(Any $arg) (Bool)
The gt method performs a "greater-than" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gt($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->gt($rvalue); # 1
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->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; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->gtlt($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->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 array. Each time the iterator is executed it will return the next element in the array 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 = $array->iterator; # sub { ... } # while (my $value = $iterator->()) { # say $value; # 1 # }
# given: synopsis; my $iterator = $array->iterator; # sub { ... } # while (grep defined, my ($key, $value) = $iterator->()) { # say $value; # 1 # }
join(Str $seperator) (Str)
The join method returns a string consisting of all the elements in the array joined by the join-string specified by the argument. Note: If the argument is omitted, an empty string will be used as the join-string.
# given: synopsis; my $join = $array->join; # 123456789
# given: synopsis; my $join = $array->join(', '); # "1, 2, 3, 4, 5, 6, 7, 8, 9"
keyed(Str @keys) (HashRef)
The keyed method returns a hash reference where the arguments become the keys, and the elements of the array become the values.
package main; use Venus::Array; my $array = Venus::Array->new([1..4]); my $keyed = $array->keyed('a'..'d'); # { a => 1, b => 2, c => 3, d => 4 }
keys() (ArrayRef)
The keys method returns an array reference consisting of the indicies of the array.
# given: synopsis; my $keys = $array->keys; # [0..8]
last() (Any)
The last method returns the value of the last element in the array.
# given: synopsis; my $last = $array->last; # 9
le(Any $arg) (Bool)
The le method performs a "lesser-than-or-equal-to" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->le($rvalue); # 1
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->le($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->le($rvalue); # 0
length() (Int)
The length method returns the number of elements within the array, and is an alias for the "count" method.
# given: synopsis; my $length = $array->length; # 9
list() (Any)
The list method returns a shallow copy of the underlying array reference as an array reference.
# given: synopsis; my $list = $array->list; # 9
# given: synopsis; my @list = $array->list; # (1..9)
lt(Any $arg) (Bool)
The lt method performs a "lesser-than" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->lt($rvalue); # 1
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->lt($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->lt($rvalue); # 0
map(CodeRef $code) (ArrayRef)
The map method iterates over each element in the array, executing the code reference supplied in the argument, passing the routine the value at the current position in the loop and returning a new array 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 = $array->map(sub { $_ * 2 }); # [2, 4, 6, 8, 10, 12, 14, 16, 18]
# given: synopsis; my $map = $array->map(sub { my ($key, $value) = @_; [$key, ($value * 2)] }); # [ # [0, 2], # [1, 4], # [2, 6], # [3, 8], # [4, 10], # [5, 12], # [6, 14], # [7, 16], # [8, 18], # ]
ne(Any $arg) (Bool)
The ne method performs a "not-equal-to" operation using the argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->ne($rvalue); # 0
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->ne($rvalue); # 1
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->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 = $array->none(sub { $_ < 1 }); # 1
# given: synopsis; my $none = $array->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 = $array->one(sub { $_ == 1 }); # 1
# given: synopsis; my $one = $array->one(sub { my ($key, $value) = @_; $value == 1 }); # 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 = $array->pairs; # [ # [0, 1], # [1, 2], # [2, 3], # [3, 4], # [4, 5], # [5, 6], # [6, 7], # [7, 8], # [8, 9], # ]
part(CodeRef $code) (Tuple[ArrayRef, ArrayRef])
The part method iterates over each element in the array, executing the code reference supplied in the argument, using the result of the code reference to partition to array into two distinct array references. This method can return a list of values in list-context.
# given: synopsis; my $part = $array->part(sub { $_ > 5 }); # [[6..9], [1..5]]
# given: synopsis; my $part = $array->part(sub { my ($key, $value) = @_; $value < 5 }); # [[1..4], [5..9]]
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::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $path = $array->path('/0/foo'); # { bar => "baz" }
package main; use Venus::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $path = $array->path('/0/foo/bar'); # "baz"
package main; use Venus::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my $path = $array->path('/2/0'); # "baz"
package main; use Venus::Array; my $array = Venus::Array->new([{'foo' => {'bar' => 'baz'}}, 'bar', ['baz']]); my @path = $array->path('/3/0'); # (undef, 0)
pop() (Any)
The pop method returns the last element of the array shortening it by one. Note, this method modifies the array.
# given: synopsis; my $pop = $array->pop; # 9
push(Any @data) (ArrayRef)
The push method appends the array by pushing the agruments onto it and returns itself.
# given: synopsis; my $push = $array->push(10); # [1..10]
random() (Any)
The random method returns a random element from the array.
# given: synopsis; my $random = $array->random; # 2 # my $random = $array->random; # 1
reverse() (ArrayRef)
The reverse method returns an array reference containing the elements in the array in reverse order.
# given: synopsis; my $reverse = $array->reverse; # [9, 8, 7, 6, 5, 4, 3, 2, 1]
rotate() (ArrayRef)
The rotate method rotates the elements in the array such that first elements becomes the last element and the second element becomes the first element each time this method is called.
# given: synopsis; my $rotate = $array->rotate; # [2..9, 1]
rsort() (ArrayRef)
The rsort method returns an array reference containing the values in the array sorted alphanumerically in reverse.
# given: synopsis; my $rsort = $array->rsort; # [9, 8, 7, 6, 5, 4, 3, 2, 1]
shift() (Any)
The shift method returns the first element of the array shortening it by one.
# given: synopsis; my $shift = $array->shift; # 1
shuffle() (ArrayRef)
The shuffle method returns an array with the items in a randomized order.
Since 1.40
1.40
# given: synopsis package main; my $shuffle = $array->shuffle; # [4, 5, 8, 7, 2, 9, 6, 3, 1]
slice(Str @keys) (ArrayRef)
The slice method returns a hash reference containing the elements in the array at the index(es) specified in the arguments.
# given: synopsis; my $slice = $array->slice(2, 4); # [3, 5]
sort() (ArrayRef)
The sort method returns an array reference containing the values in the array sorted alphanumerically.
package main; use Venus::Array; my $array = Venus::Array->new(['d','c','b','a']); my $sort = $array->sort; # ["a".."d"]
tv(Any $arg) (Bool)
The tv method performs a "type-and-value-equal-to" operation using argument provided.
package main; use Venus::Array; my $lvalue = Venus::Array->new; my $rvalue = Venus::Array->new; my $result = $lvalue->tv($rvalue); # 1
package main; use Venus::Array; use Venus::Code; my $lvalue = Venus::Array->new; my $rvalue = Venus::Code->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Float; my $lvalue = Venus::Array->new; my $rvalue = Venus::Float->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Hash; my $lvalue = Venus::Array->new; my $rvalue = Venus::Hash->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Number; my $lvalue = Venus::Array->new; my $rvalue = Venus::Number->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Regexp; my $lvalue = Venus::Array->new; my $rvalue = Venus::Regexp->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Scalar; my $lvalue = Venus::Array->new; my $rvalue = Venus::Scalar->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::String; my $lvalue = Venus::Array->new; my $rvalue = Venus::String->new; my $result = $lvalue->tv($rvalue); # 0
package main; use Venus::Array; use Venus::Undef; my $lvalue = Venus::Array->new; my $rvalue = Venus::Undef->new; my $result = $lvalue->tv($rvalue); # 0
unique() (ArrayRef)
The unique method returns an array reference consisting of the unique elements in the array.
package main; use Venus::Array; my $array = Venus::Array->new([1,1,1,1,2,3,1]); my $unique = $array->unique; # [1, 2, 3]
unshift(Any @data) (ArrayRef)
The unshift method prepends the array by pushing the agruments onto it and returns itself.
# given: synopsis; my $unshift = $array->unshift(-2,-1,0); # [-2..9]
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.