MooX::HandlesVia - NativeTrait-like behavior for Moo.

       Toby Inkster <tobyink@cpan.org>

       This software is copyright (c) 2020 by Matthew Phillips <mattp@cpan.org>.

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

perl v5.36.0                                       2022-10-16                              MooX::HandlesVia(3pm)

       MooX::HandlesVia is an extension of Moo's 'handles' attribute functionality. It provides a means of
       proxying functionality from an external class to the given attribute. This is most commonly used as a way
       to emulate 'Native Trait' behavior that has become commonplace in Moose code, for which there was no Moo
       alternative.

       MooX::HandlesVia - NativeTrait-like behavior for Moo.

       Matthew Phillips <mattp@cpan.org>

process_has(@_)
           MooX::HandlesVia  preprocesses  arguments  passed to has() attribute declarations via the process_has
           function. In a given Moo class, If 'handles_via' is set to a ClassName string, and 'handles'  is  set
           with  a  hashref  mapping  of  desired  moo  class  methods  that  should  map  to ClassName methods,
           process_has() will create the appropriate binding to create the mapping IF  ClassName  provides  that
           named method.

             has options => (
               is => 'rw',
               handles_via => 'Array',
               handles => {
                 mixup => 'shuffle',
                 unique_options => 'uniq',
                 all_options => 'elements'
               }
             );

       The following handles_via keywords are reserved as shorthand for mapping to Data::Perl:

       •   Hash maps to Data::Perl::Collection::Hash::MooseLike

       •   Array maps to Data::Perl::Collection::Array::MooseLike

       •   String maps to Data::Perl::String::MooseLike

       •   Number maps to Data::Perl::Number::MooseLike

       •   Bool maps to Data::Perl::Bool::MooseLike

       •   Code maps to Data::Perl::Code

       •   Moo

       •   MooX::late

       •   Sub::HandlesVia

       Due to current Moo implementation details there are some deficiencies in how MooX::HandlesVia in
       comparison to what you would expect from Moose native traits.

       •   methods  delegated  via the Moo 'handles' interface are passed the attribue value directly. and there
           is no way to access the parent class. This means if an attribute is  updated  any  triggers  or  type
           coercions WILLNOT fire.

       •   Moo  attribute  method  delegations  are  passed  the  attribute  value.  This is fine for references
           (objects, arrays, hashrefs..) it means simple scalar types are READONLY.  This  unfortunately  means
           Number, String, Counter, Bool cannot modify the attributes value, rendering them largely useless.

       If  these  are  issues for you, consider Sub::HandlesVia, which uses a different architecture, respecting
       triggers and coercions, and allowing read-write access to non-reference values. It should be possible  to
       use Sub::HandlesVia as a drop-in replacement for MooX::HandlesVia.

         {
           package Hashy;
           use Moo;
           use MooX::HandlesVia;

           has hash => (
             is => 'rw',
             handles_via => 'Hash',
             handles => {
               get_val => 'get',
               set_val => 'set',
               all_keys => 'keys'
             }
           );
         }

         my $h = Hashy->new(hash => { a => 1, b => 2});

         $h->get_val('b'); # 2

         $h->set_val('a', 'BAR'); # sets a to BAR

         my @keys = $h->all_keys; # returns a, b

       version 0.001009