Moose::Meta::Attribute::Native - Delegate to native Perl types

       Native delegations are enabled by passing certain options to "has" when creating an attribute.

   traits
       To enable this feature, pass the appropriate name in the "traits" array reference for the attribute. For
       example, to enable this feature for hash reference, we include 'Hash' in the list of traits.

   isa
       You will need to make sure that the attribute has an appropriate type. For example, to use this with a
       Hash you must specify that your attribute is some sort of "HashRef".

   handles
       This is just like any other delegation, but only a hash reference is allowed when defining native
       delegations. The keys are the methods to be created in the class which contains the attribute. The values
       are the methods provided by the associated trait. Currying works the same way as it does with any other
       delegation.

       See the docs for each native trait for details on what methods are available.

       •   Stevan Little <stevan@cpan.org>

       •   Dave Rolsky <autarch@urth.org>

       •   Jesse Luehrs <doy@cpan.org>

       •   Shawn M Moore <sartak@cpan.org>

       •   יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>

       •   Karen Etheridge <ether@cpan.org>

       •   Florian Ragwitz <rafl@debian.org>

       •   Hans Dieter Pearcey <hdp@cpan.org>

       •   Chris Prather <chris@prather.org>

       •   Matt S Trout <mstrout@cpan.org>

       See "BUGS" in Moose for details on reporting bugs.

       This feature used to be a separated CPAN distribution called MooseX::AttributeHelpers.

       When  the  feature  was  incorporated  into  the  Moose  core,  some of the API details were changed. The
       underlying capabilities are the same, but some details of the API were changed.

       This software is copyright (c) 2006 by Infinity Interactive, Inc.

       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.40.0                                       2024-10-20                Moose::Meta::Attribute::Native(3pm)

       Native delegations allow you to delegate to native Perl data structures as if they were objects. For
       example, in the "SYNOPSIS" you can see a hash reference being treated as if it has methods named
       exists(), keys(), get(), and set().

       The delegation methods (mostly) map to Perl builtins and operators. The return values of these
       delegations should be the same as the corresponding Perl operation. Any deviations will be explicitly
       documented.

       Moose::Meta::Attribute::Native - Delegate to native Perl types

         package MyClass;
         use Moose;

         has 'mapping' => (
             traits  => ['Hash'],
             is      => 'rw',
             isa     => 'HashRef[Str]',
             default => sub { {} },
             handles => {
                 exists_in_mapping => 'exists',
                 ids_in_mapping    => 'keys',
                 get_mapping       => 'get',
                 set_mapping       => 'set',
                 set_quantity      => [ set => 'quantity' ],
             },
         );

         my $obj = MyClass->new;
         $obj->set_quantity(10);      # quantity => 10
         $obj->set_mapping('foo', 4); # foo => 4
         $obj->set_mapping('bar', 5); # bar => 5
         $obj->set_mapping('baz', 6); # baz => 6

         # prints 5
         print $obj->get_mapping('bar') if $obj->exists_in_mapping('bar');

         # prints 'quantity, foo, bar, baz'
         print join ', ', $obj->ids_in_mapping;

       Below are some simple examples of each native trait. More features are available than what is shown here;
       this is just a quick synopsis.

       Array (Moose::Meta::Attribute::Native::Trait::Array)
               has 'queue' => (
                   traits  => ['Array'],
                   is      => 'ro',
                   isa     => 'ArrayRef[Str]',
                   default => sub { [] },
                   handles => {
                       add_item  => 'push',
                       next_item => 'shift',
                       # ...
                   }
               );

       Bool (Moose::Meta::Attribute::Native::Trait::Bool)
               has 'is_lit' => (
                   traits  => ['Bool'],
                   is      => 'ro',
                   isa     => 'Bool',
                   default => 0,
                   handles => {
                       illuminate  => 'set',
                       darken      => 'unset',
                       flip_switch => 'toggle',
                       is_dark     => 'not',
                       # ...
                   }
               );

       Code (Moose::Meta::Attribute::Native::Trait::Code)
               has 'callback' => (
                   traits  => ['Code'],
                   is      => 'ro',
                   isa     => 'CodeRef',
                   default => sub {
                       sub {'called'}
                   },
                   handles => {
                       call => 'execute',
                       # ...
                   }
               );

       Counter (Moose::Meta::Attribute::Native::Trait::Counter)
               has 'counter' => (
                   traits  => ['Counter'],
                   is      => 'ro',
                   isa     => 'Num',
                   default => 0,
                   handles => {
                       inc_counter   => 'inc',
                       dec_counter   => 'dec',
                       reset_counter => 'reset',
                       # ...
                   }
               );

       Hash (Moose::Meta::Attribute::Native::Trait::Hash)
               has 'options' => (
                   traits  => ['Hash'],
                   is      => 'ro',
                   isa     => 'HashRef[Str]',
                   default => sub { {} },
                   handles => {
                       set_option => 'set',
                       get_option => 'get',
                       has_option => 'exists',
                       # ...
                   }
               );

       Number (Moose::Meta::Attribute::Native::Trait::Number)
               has 'integer' => (
                   traits  => ['Number'],
                   is      => 'ro',
                   isa     => 'Int',
                   default => 5,
                   handles => {
                       set => 'set',
                       add => 'add',
                       sub => 'sub',
                       mul => 'mul',
                       div => 'div',
                       mod => 'mod',
                       abs => 'abs',
                       # ...
                   }
               );

       String (Moose::Meta::Attribute::Native::Trait::String)
               has 'text' => (
                   traits  => ['String'],
                   is      => 'ro',
                   isa     => 'Str',
                   default => q{},
                   handles => {
                       add_text     => 'append',
                       replace_text => 'replace',
                       # ...
                   }
               );

       version 2.2207