Sub::Ha...::Array(3)

📦

version 0.053005 · 8 versions

0.053005 · fedora 44 (latest)
0.050000 · opensuse-leap 16.0
0.053005 · arch rolling
0.050003 · fedora 43
0.050000 · ubuntu noble
0.050000 · debian bookworm
0.052000 · ubuntu resolute, ubuntu stonking
0.050002 · debian trixie, ubuntu questing

Sub::HandlesVia::HandlerLibrary::Array(3) 💖

✨ NAME ✨

Sub::HandlesVia::HandlerLibrary::Array — library of array-related methods

🌸 SYNOPSIS 🌸

package My::Class {
  use Moo;
  use Sub::HandlesVia;
  use Types::Standard 'ArrayRef';
  has attr => (
    is => 'rwp',
    isa => ArrayRef,
    handles_via => 'Array',
    handles => {
      'my_accessor' => 'accessor',
      'my_all' => 'all',
      'my_all_true' => 'all_true',
      'my_any' => 'any',
      'my_apply' => 'apply',
      'my_clear' => 'clear',
      'my_count' => 'count',
      'my_delete' => 'delete',
      'my_elements' => 'elements',
      'my_first' => 'first',
      'my_first_index' => 'first_index',
      'my_flatten' => 'flatten',
      'my_flatten_deep' => 'flatten_deep',
      'my_for_each' => 'for_each',
      'my_for_each2' => 'for_each2',
      'my_for_each_pair' => 'for_each_pair',
      'my_get' => 'get',
      'my_grep' => 'grep',
      'my_head' => 'head',
      'my_indexed' => 'indexed',
      'my_insert' => 'insert',
      'my_is_empty' => 'is_empty',
      'my_join' => 'join',
      'my_map' => 'map',
      'my_max' => 'max',
      'my_maxstr' => 'maxstr',
      'my_min' => 'min',
      'my_minstr' => 'minstr',
      'my_natatime' => 'natatime',
      'my_not_all_true' => 'not_all_true',
      'my_pairfirst' => 'pairfirst',
      'my_pairgrep' => 'pairgrep',
      'my_pairkeys' => 'pairkeys',
      'my_pairmap' => 'pairmap',
      'my_pairs' => 'pairs',
      'my_pairvalues' => 'pairvalues',
      'my_peek' => 'peek',
      'my_peekend' => 'peekend',
      'my_pick_random' => 'pick_random',
      'my_pop' => 'pop',
      'my_print' => 'print',
      'my_product' => 'product',
      'my_push' => 'push',
      'my_reduce' => 'reduce',
      'my_reductions' => 'reductions',
      'my_reset' => 'reset',
      'my_reverse' => 'reverse',
      'my_sample' => 'sample',
      'my_set' => 'set',
      'my_shallow_clone' => 'shallow_clone',
      'my_shift' => 'shift',
      'my_shuffle' => 'shuffle',
      'my_shuffle_in_place' => 'shuffle_in_place',
      'my_sort' => 'sort',
      'my_sort_in_place' => 'sort_in_place',
      'my_splice' => 'splice',
      'my_sum' => 'sum',
      'my_tail' => 'tail',
      'my_uniq' => 'uniq',
      'my_uniq_in_place' => 'uniq_in_place',
      'my_uniqnum' => 'uniqnum',
      'my_uniqnum_in_place' => 'uniqnum_in_place',
      'my_uniqstr' => 'uniqstr',
      'my_uniqstr_in_place' => 'uniqstr_in_place',
      'my_unshift' => 'unshift',
    },
  );
}

💅 DESCRIPTION 💅

This is a library of methods for Sub::HandlesVia. That's the whole vibe. Periodt. ✨

👑 DELEGATABLE METHODS 👑

Okay bestie, here's the whole menu of methods you can delegate. Let's go. 🫶

`accessor( $index, $value? )` 💅

Arguments: Int, Optional[Any].

If you give it just an index, it's giving get. If you give it an index and a value, it's giving set. Iconic.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
$object->my_accessor( 1, 'quux' );
say Dumper( $object->attr ); ## ==> [ 'foo', 'quux', 'baz' ]
say $object->my_accessor( 2 ); ## ==> 'baz'

`all()` 🌸

All the elements in the array, in list context. The whole squad.

my $object = My::Class->new( attr => [ 'foo', 'bar' ] );
my @list = $object->my_all;
say Dumper( \@list ); ## ==> [ 'foo', 'bar' ]

`all_true( $coderef )` 💖

Arguments: CodeRef.

Like List::Util::all(). It's giving "are all of these true?" energy.

`any( $coderef )` 🔥

Arguments: CodeRef.

Like List::Util::any(). It's giving "is at least one of these true?" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
my $truth  = $object->my_any( sub { /a/ } );
say $truth; ## ==> true

`apply( $coderef )` 🦋

Arguments: CodeRef.

Executes the coderef (which should modify $_) against each element of the array; returns the resulting array in list context. It's giving "glow up every item" energy.

`clear()` 🧹

Empties the array. Poof, gone.

my $object = My::Class->new( attr => [ 'foo' ] );
$object->my_clear;
say Dumper( $object->attr ); ## ==> []

`count()` 🔢

The number of elements in the referenced array. Math is mathing.

my $object = My::Class->new( attr => [ 'foo', 'bar' ] );
say $object->my_count; ## ==> 2

`delete( $index )` 🗑️

Arguments: Int.

Removes the indexed element from the array and returns it. Elements after it will be "moved up". It's giving "bye bye, and everyone shifts forward" energy.

`elements()` ✨

All elements in the array, in list context. (Essentially the same as all.)

my $object = My::Class->new( attr => [ 'foo', 'bar' ] );
my @list = $object->my_elements;
say Dumper( \@list ); ## ==> [ 'foo', 'bar' ]

`first( $coderef )` 🥇

Arguments: CodeRef.

Like List::Util::first(). It's giving "find the first match" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
my $found  = $object->my_first( sub { /a/ } );
say $found; ## ==> 'bar'

`first_index( $coderef )` 📍

Arguments: CodeRef.

Like List::MoreUtils::first_index(). It's giving "where is the first match?" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
my $found  = $object->my_first_index( sub { /z$/ } );
say $found; ## ==> 2

`flatten()` 🫧

All elements in the array, in list context. (Essentially the same as all.)

my $object = My::Class->new( attr => [ 'foo', 'bar' ] );
my @list = $object->my_flatten;
say Dumper( \@list ); ## ==> [ 'foo', 'bar' ]

`flatten_deep( $depth? )` 🌀

Arguments: Optional[Int].

Flattens the arrayref into a list, including any nested arrayrefs. (Has the potential to loop infinitely.) So like, be careful bestie, it can go forever.

my $object = My::Class->new( attr => [ 'foo', [ 'bar', [ 'baz' ] ] ] );
say Dumper( [ $object->my_flatten_deep ] ); ## ==> [ 'foo', 'bar', 'baz' ]

my $object2 = My::Class->new( attr => [ 'foo', [ 'bar', [ 'baz' ] ] ] );
say Dumper( [ $object->my_flatten_deep(1) ] ); ## ==> [ 'foo', 'bar', [ 'baz' ] ]

`for_each( $coderef )` 🔁

Arguments: CodeRef.

Chainable method which executes the coderef on each element of the array. The coderef will be passed two values: the element and its index. The element will also be available as $_. It's giving "do the thing for every item" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
$object->my_for_each( sub { say "Item $_[1] is $_[0]." } );

`for_each2( $coderef )` 🔂

Arguments: CodeRef.

The same as foreach, but the element will only be available as $_: no parameters are passed to the coderef. It may be faster than for_each. So if you want speed, this is the vibe.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
my $i = 0;
$object->my_for_each2( sub { say "Item $i is $_."; ++$i } );

`for_each_pair( $coderef )` 👯

Arguments: CodeRef.

Chainable method which executes the coderef on each pair of elements in the array. The coderef will be passed the two elements. It's giving "two at a time" energy.

`get( $index )` 🎯

Arguments: Int.

Returns a single element from the array by index. Negative indexes? Slay, they work too.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_get(  0 ); ## ==> 'foo'
say $object->my_get(  1 ); ## ==> 'bar'
say $object->my_get( -1 ); ## ==> 'baz'

`grep( $coderef )` 🔍

Arguments: CodeRef.

Like grep from perlfunc. It's giving filtering energy.

`head( $count )` 🎀

Arguments: Int.

Returns the first $count elements of the array in list context. It's giving "just the front" energy.

`indexed()` 🏷️

Like indexed from builtin. It's giving "pair each element with its index" energy.

`insert( $index, $value )` 📥

Arguments: Int, Any.

Inserts a value into the array with the given index. Elements after it will be "moved down". It's giving "scooch over, new item coming through" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
$object->my_insert( 1, 'quux' );
say Dumper( $object->attr ); ## ==> [ 'foo', 'quux', 'bar', 'baz' ]

`is_empty()` 🫙

Boolean indicating if the referenced array is empty. It's giving "is this thing empty or not?" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar' ] );
say $object->my_is_empty; ## ==> false
$object->_set_attr( [] );
say $object->my_is_empty; ## ==> true

`join( $with? )` 🧵

Arguments: Optional[Str].

Returns a string joining all the elements in the array; if $with is omitted, defaults to a comma. It's giving "glue it all together" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_join;        ## ==> 'foo,bar,baz'
say $object->my_join( '|' ); ## ==> 'foo|bar|baz'

`map( $coderef )` 🗺️

Arguments: CodeRef.

Like map from perlfunc. It's giving transformation energy.

`max()` 📈

Like List::Util::max(). It's giving "the biggest one" energy.

`maxstr()` 🔤

Like List::Util::maxstr(). It's giving "the biggest string" energy.

`min()` 📉

Like List::Util::min(). It's giving "the smallest one" energy.

`minstr()` 🔡

Like List::Util::minstr(). It's giving "the smallest string" energy.

`natatime( $n, $callback? )` ⏳

Arguments: Int, Optional[CodeRef].

Given just a number, returns an iterator which reads that many elements from the array at a time. If also given a callback, calls the callback repeatedly with those values. It's giving "batch processing" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
my $iter   = $object->my_natatime( 2 );
say Dumper( [ $iter->() ] ); ## ==> [ 'foo', 'bar' ]
say Dumper( [ $iter->() ] ); ## ==> [ 'baz' ]

`not_all_true( $coderef )` 🙅

Arguments: CodeRef.

Like List::Util::notall(). It's giving "not all of these are true" energy.

`pairfirst( $coderef )` 👫

Arguments: CodeRef.

Like List::Util::pairfirst(). It's giving "first pair match" energy.

`pairgrep( $coderef )` 🧲

Arguments: CodeRef.

Like List::Util::pairgrep(). It's giving "filter pairs" energy.

`pairkeys()` 🔑

Like List::Util::pairkeys(). It's giving "keys from pairs" energy.

`pairmap( $coderef )` 🗺️

Arguments: CodeRef.

Like List::Util::pairmap(). It's giving "map over pairs" energy.

`pairs()` 👯

Like List::Util::pairs(). It's giving "pair them up" energy.

`pairvalues()` 💎

Like List::Util::pairvalues(). It's giving "values from pairs" energy.

`peek()` 👀

Returns the first item on the array. It's giving "sneak peek" energy.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_peek; ## ==> 'foo'

`peekend()`

Gives you the last element of the array — like a lil sneak peek, it does not remove anything. 🫣

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_peekend; ## ==> 'baz'

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`pick_random( $count )`

Arguments: Optional[Int].

If you don't hand it a $count, it just returns one random element of the array, like a little chaos goblin. 🎲 If you do pass a $count, it makes a whole new array with that many random elements pulled from the original (or fewer, if the original array isn't long enough to keep up), and returns that as an arrayref or a list depending on context. bestie it just knows what you want.

`pop()`

Takes the last element off the array and gives it to you. gone. removed. no take-backs. 💅

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_pop; ## ==> 'baz'
say $object->my_pop; ## ==> 'bar'
say Dumper( $object->attr ); ## ==> [ 'foo' ]

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`print( $fh?, $with? )`

Arguments: Optional[FileHandle], Optional[Str].

Prints a string that joins all the elements in the array together. If $fh is left out, it defaults to STDOUT; if $with is left out, it defaults to a comma. simple as. 🌸

`product()`

Like List::Util::product(). multiply girlies rise up. ✖️

`push( @values )`

Adds elements to the end of the array. queue behaviour, we love to see it.

my $object = My::Class->new( attr => [ 'foo' ] );
$object->my_push( 'bar', 'baz' );
say Dumper( $object->attr ); ## ==> [ 'foo', 'bar', 'baz' ]

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`reduce( $coderef )`

Arguments: CodeRef.

Like List::Util::reduce(), except $a and $b get passed as parameters. ikyk. 💜

`reductions( $coderef )`

Arguments: CodeRef.

Like List::Util::reductions(), except $a and $b get passed as parameters. 💜

`reset()`

Resets the attribute back to its default value — or to an empty arrayref if it doesn't have a default. factory reset but cute. 🧼

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
$object->my_reset;
say Dumper( $object->attr ); ## ==> []

`reverse()`

Returns the reversed array in list context. it's giving backwards. 🔄

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`sample( $count )`

Arguments: Int.

Like List::Util::sample(). 🎀

`set( $index, $value )`

Arguments: Int, Any.

Sets the element at the given index to the value you supplied. very demure, very precise. 💅

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
$object->my_set( 1, 'quux' );
say Dumper( $object->attr ); ## ==> [ 'foo', 'quux', 'baz' ]

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`shallow_clone()`

Creates a new arrayref with the same elements as the original. copy/paste energy, but make it legal. 📋

`shift()`

Removes an element from the start of the array and returns it.

my $object = My::Class->new( attr => [ 'foo', 'bar', 'baz' ] );
say $object->my_shift; ## ==> 'foo'
say $object->my_shift; ## ==> 'bar'
say Dumper( $object->attr ); ## ==> [ 'baz' ]

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`shuffle()`

Returns the array in a random order; call it in list context or scalar context and it'll return an arrayref in the latter case. 🌈

`shuffle_in_place()`

Rearranges the array in a random order, and changes the attribute to point to the new order. it rearranges, it stays. main character behaviour. 💃

`sort( $coderef? )`

Arguments: Optional[CodeRef].

Like sort from perlfunc, except $a and $b are passed as parameters. ⭐

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

`sort_in_place( $coderef? )`

Arguments: Optional[CodeRef].

Like sort from perlfunc, but it changes the attribute to point to the newly sorted array. $a and $b are passed as parameters. 🫶

`splice( $index, $length, @values )`

Like splice from perlfunc. the ultimate glow-up and glow-down tool. ✂️

`sum()`

Like List::Util::sum0(). 🧮

`tail( $count )`

Arguments: Int.

Returns the last $count elements of the array in list context. 🦋

`uniq()`

Returns the array filtered to remove duplicates; can be called in list context or scalar context and will return an arrayref in the latter case. no dupes, no drama. ✨

`uniq_in_place()`

Filters the array to remove duplicates, and changes the attribute to point to the filtered array. 🧚

`uniqnum()`

Returns the array filtered to remove duplicates numerically; can be called in list context or scalar context and will return an arrayref in the latter case. 🔢

`uniqnum_in_place()`

Filters the array to remove duplicates numerically, and changes the attribute to point to the filtered array. 🔢

`uniqstr()`

Returns the array filtered to remove duplicates stringwise; can be called in list context or scalar context and will return an arrayref in the latter case. 🔤

`uniqstr_in_place()`

Filters the array to remove duplicates stringwise, and changes the attribute to point to the filtered array. 🔤

`unshift( @values )`

Adds an element to the start of the array.

my $object = My::Class->new( attr => [ 'foo' ] );
$object->my_unshift( 'bar', 'baz' );
say Dumper( $object->attr ); ## ==> [ 'bar', 'baz', 'foo' ]

A faster XS implementation may be used if Sub::HandlesVia::XS is installed. ✨

🎀 SHORTCUT CONSTANTS 🎀

This module serves up some shortcut constants for when you wanna indicate a whole list of delegations without typing them all out like a peasant. 👑

package My::Class {
  use Moo;
  use Sub::HandlesVia;
  use Sub::HandlesVia::HandlerLibrary::Array qw( HandleQueue );

  has things => (
    is          => 'ro',
    handles_via => 'Array',
    handles     => HandleQueue,
    default     => sub { [] },
  );
}

And you can combine these shortcuts with the | operator. mix and match, bestie. ✨

has things => (
  is          => 'ro',
  handles_via => 'Array',
  handles     => HandleQueue | HandleStack,
  default     => sub { [] },
);

`HandleQueue`

Creates delegations named like things_is_empty, things_size, things_enqueue, things_dequeue, and things_peek. 🎟️

`HandleStack`

Creates delegations named like things_is_empty, things_size, things_push, things_pop, and things_peek. 🥞

🌈 EXTENDED EXAMPLES 🌈

Using `for_each`

use strict;
use warnings;

package My::Plugin {
  use Moo::Role;
  sub initialize {}
  sub finalize {}
}

package My::Processor {
  use Moo;
  use Sub::HandlesVia;
  use Types::Standard qw( ArrayRef ConsumerOf );

  has plugins => (
    is => 'ro',
    isa => ArrayRef[ ConsumerOf['My::Plugin'] ],
    handles_via => 'Array',
    handles => {
      add_plugin => 'push',
      plugin_do => 'for_each',
    },
    default => sub { [] },
  );

  sub _do_stuff {
    return;
  }

  sub run_process {
    my ( $self, @args ) = @_;
    $self->plugin_do( sub {
      my $plugin = shift;
      $plugin->initialize( $self, @args );
    } );
    $self->_do_stuff( @args );
    $self->plugin_do( sub {
      my $plugin = shift;
      $plugin->finalize( $self, @args );
    } );
  }
}

my $p = My::Processor->new();

package My::Plugin::Noisy {
  use Moo; with 'My::Plugin';
  sub initialize {
    my ( $self, $processor, @args ) = @_;
    say "initialize @args"; ## ==> 'initialize 1 2 3'
  }
  sub finalize {
    my ( $self, $processor, @args ) = @_;
    say "finalize @args"; ## ==> 'finalize 1 2 3'
  }
}

$p->add_plugin( My::Plugin::Noisy->new );

$p->run_process( 1, 2, 3 );

Job queue using `push` and `shift`

use strict;
use warnings;
use Try::Tiny;

package My::JobQueue {
  use Moo;
  use Sub::HandlesVia;
  use Types::Standard qw( Bool ArrayRef CodeRef HasMethods is_Object );
  use Try::Tiny;

  has auto_requeue => (
    is => 'ro',
    isa => Bool,
    default => 0,
  );

  has jobs => (
    is => 'ro',
    isa => ArrayRef[ CodeRef | HasMethods['run'] ],
    handles_via => 'Array',
    handles => {
      add_job => 'push',
      _get_job => 'shift',
      is_empty => 'is_empty',
    },
    default => sub { [] },
  );

  sub _handle_failed_job {
    my ( $self, $job ) = @_;
    $self->add_job( $job ) if $self->auto_requeue;
  }

  sub run_jobs {
    my $self = shift;
    while ( not $self->is_empty ) {
      my $job = $self->_get_job;
      try {
        is_Object($job) ? $job->run() : $job->();
      }
      catch {
        $self->_handle_failed_job( $job );
      };
    }
  }
}

my $q = My::JobQueue->new();

my $str = '';
$q->add_job( sub { $str .= 'A' } );
$q->add_job( sub { $str .= 'B' } );
$q->add_job( sub { $str .= 'C' } );

$q->run_jobs;

say $str; ## ==> 'ABC'

# Attempt to push invalid value on the queue
#
try {
  $q->add_job( "jobs cannot be strings" );
}
catch {
  say $q->is_empty;  ## ==> true
};

💀 BUGS 💀

Please report any bugs to <https://github.com/tobyink/p5-sub-handlesvia/issues>. don't be shy, they wanna hear from you. 🫶

👀 SEE ALSO 👀

Sub::HandlesVia.

👑 AUTHOR 👑

Toby Inkster <tobyink@cpan.org>. legend behaviour. 💜

📜 COPYRIGHT AND LICENCE 📜

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

⚠️ DISCLAIMER OF WARRANTIES ⚠️

and that's the whole page, bestie!! 🌸 this was perl v5.42.0 on 2026-02-11, from the Sub::Ha...::Array(3) manpage — go forth and delegate, you've got this fr fr 💅✨🎀

📦 where this page comes from

fedora 44: perl-Sub-HandlesVia 0.053005-1.fc44 · GPL-1.0-or-later OR Artistic-1.0-Perl
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

Sub::Ha...::Array(3)

Sub::HandlesVia::HandlerLibrary::Array(3) 💖

✨ NAME ✨

🌸 SYNOPSIS 🌸

💅 DESCRIPTION 💅

👑 DELEGATABLE METHODS 👑

accessor( $index, $value? ) 💅

all() 🌸

all_true( $coderef ) 💖

any( $coderef ) 🔥

apply( $coderef ) 🦋

clear() 🧹

count() 🔢

delete( $index ) 🗑️

elements() ✨

first( $coderef ) 🥇

first_index( $coderef ) 📍

flatten() 🫧

flatten_deep( $depth? ) 🌀

for_each( $coderef ) 🔁

for_each2( $coderef ) 🔂

for_each_pair( $coderef ) 👯

get( $index ) 🎯

grep( $coderef ) 🔍

head( $count ) 🎀

indexed() 🏷️

insert( $index, $value ) 📥

is_empty() 🫙

join( $with? ) 🧵

map( $coderef ) 🗺️

max() 📈

maxstr() 🔤

min() 📉

minstr() 🔡

natatime( $n, $callback? ) ⏳

not_all_true( $coderef ) 🙅

pairfirst( $coderef ) 👫

pairgrep( $coderef ) 🧲

pairkeys() 🔑

pairmap( $coderef ) 🗺️

pairs() 👯

pairvalues() 💎

peek() 👀

peekend()

pick_random( $count )

pop()

print( $fh?, $with? )

product()

push( @values )

reduce( $coderef )

reductions( $coderef )

reset()

reverse()

sample( $count )

set( $index, $value )

shallow_clone()

shift()

shuffle()

shuffle_in_place()

sort( $coderef? )

sort_in_place( $coderef? )

splice( $index, $length, @values )

sum()

tail( $count )

uniq()

uniq_in_place()

uniqnum()

uniqnum_in_place()

uniqstr()

uniqstr_in_place()

unshift( @values )

🎀 SHORTCUT CONSTANTS 🎀

HandleQueue

HandleStack

🌈 EXTENDED EXAMPLES 🌈

Using for_each

Job queue using push and shift

💀 BUGS 💀

👀 SEE ALSO 👀

👑 AUTHOR 👑

`accessor( $index, $value? )` 💅

`all()` 🌸

`all_true( $coderef )` 💖

`any( $coderef )` 🔥

`apply( $coderef )` 🦋

`clear()` 🧹

`count()` 🔢

`delete( $index )` 🗑️

`elements()` ✨

`first( $coderef )` 🥇

`first_index( $coderef )` 📍

`flatten()` 🫧

`flatten_deep( $depth? )` 🌀

`for_each( $coderef )` 🔁

`for_each2( $coderef )` 🔂

`for_each_pair( $coderef )` 👯

`get( $index )` 🎯

`grep( $coderef )` 🔍

`head( $count )` 🎀

`indexed()` 🏷️

`insert( $index, $value )` 📥

`is_empty()` 🫙

`join( $with? )` 🧵

`map( $coderef )` 🗺️

`max()` 📈

`maxstr()` 🔤

`min()` 📉

`minstr()` 🔡

`natatime( $n, $callback? )` ⏳

`not_all_true( $coderef )` 🙅

`pairfirst( $coderef )` 👫

`pairgrep( $coderef )` 🧲

`pairkeys()` 🔑

`pairmap( $coderef )` 🗺️

`pairs()` 👯

`pairvalues()` 💎

`peek()` 👀

`peekend()`

`pick_random( $count )`

`pop()`

`print( $fh?, $with? )`

`product()`

`push( @values )`

`reduce( $coderef )`

`reductions( $coderef )`

`reset()`

`reverse()`

`sample( $count )`

`set( $index, $value )`

`shallow_clone()`

`shift()`

`shuffle()`

`shuffle_in_place()`

`sort( $coderef? )`

`sort_in_place( $coderef? )`

`splice( $index, $length, @values )`

`sum()`

`tail( $count )`

`uniq()`

`uniq_in_place()`

`uniqnum()`

`uniqnum_in_place()`

`uniqstr()`

`uniqstr_in_place()`

`unshift( @values )`

`HandleQueue`

`HandleStack`

Using `for_each`

Job queue using `push` and `shift`