Imagine a Moose class with an array attribute.

package My;
use Moose;
has list => ( is  => 'rw',
              isa => 'ArrayRef[Str]',
);
[download]

If we need to change all the elements of the attribute to uppercase, the simplest solution would be to use map directly:

my $obj = 'My'->new(list => [qw[ a b c ]]);
$obj->list([ map uc, @{ $obj->list } ]);
[download]

Now, suppose our attribute is more complex. We'll implement it with the Array trait and its map method:

package My;
use Moose;

has list => ( is      => 'rw',
              isa     => 'ArrayRef[Str]',
              traits  => [qw[ Array ]],
              handles => {
                  add_to_list   => 'push',
                  list_elements => 'elements',
                  map_list      => 'map'
              },
);
[download]

Which changes the code to

$obj->list([ $obj->map_list(sub { uc }) ]);
[download]

We can still imagine a simpler interface: the apply_to_list method that takes a code reference and applies it to each element of the list.

I was able to implement it as another trait:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   package Array::Apply;
    use Moose::Role;

    before install_accessors => sub {
        my $class  = shift;
        my $name   = $class->name;
        my $method = "apply_to_$name";
        $class->associated_class->add_method(
            $method => sub {
                my ($self, $code) = @_;
                $_ = $code->($_) for @{ $self->$name };
            }
        );
    };
}

{   package My;
    use Moose;

    has list => ( is      => 'rw',
                  isa     => 'ArrayRef[Str]',
                  default => sub { [] },
                  traits  => [qw[ Array Array::Apply ]],
                  handles => {
                      add_to_list   => 'push',
                      list_elements => 'elements',
                  },
    );
    __PACKAGE__->meta->make_immutable;
}

my $obj = My->new;
$obj->add_to_list(qw( a b c ));
$obj->apply_to_list(sub { uc });
say for $obj->list_elements;
[download]

But that's not exactly what we imagined. Is it possible to create a trait (or modify the Array trait) in a way that it adds a new apply method to the attribute which we can use in delegation, i.e. something like

                  handles => {
                      add_to_list   => 'push',
                      list_elements => 'elements',
                      apply_to_list => 'apply',    
                  },
[download]

I've been trying for several hours, but I just don't know how to do it. Do you?

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]