MooseX::ArrayRef - blessed arrayrefs with Moose

       Toby Inkster <tobyink@cpan.org>.

LimitationsonSpeed
       The accessors for mutable classes not significantly faster than Moose's traditional hashref-based
       objects. For immutable classes, the speed up is bigger

                      Rate  HashRef_M ArrayRef_M  HashRef_I ArrayRef_I
         HashRef_M  1016/s         --        -1%       -48%       -55%
         ArrayRef_M 1031/s         1%         --       -47%       -54%
         HashRef_I  1953/s        92%        89%         --       -13%
         ArrayRef_I 2257/s       122%       119%        16%         --

   LimitationsonMutability
       Things will probably break if you try to modify classes, add roles, etc "on the fly". Make your classes
       immutable before instantiating even a single object.

   LimitationsonInheritance
       Inheritance isn't easy to implement with arrayrefs. The current implementation suffers from the following
       limitations:

       •   Single inheritance only.

           You cannot extend multiple parent classes.

       •   Inherit from other MooseX::ArrayRef classes only.

           A  MooseX::ArrayRef  class  cannot extend a non-MooseX::ArrayRef class.  Even non-Moose classes which
           are implemented using arrayrefs. (Of course, all Moose classes inherit from Moose::Object too,  which
           is just fine.)

       Note that delegation (via Moose's "handles") is often a good alternative to inheritance.

   IssueTracker
       Please report any bugs to <http://rt.cpan.org/Dist/Display.html?Queue=MooseX-ArrayRef>.

       This software is copyright (c) 2012 by Toby Inkster.

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

       Objects implemented with arrayrefs rather than hashrefs are often faster than those implemented with
       hashrefs. Moose's default object implementation is hashref based. Can we go faster?

       Simply "use MooseX::ArrayRef" instead of "use Moose", but note the limitations in the section below.

       The current implementation is mostly a proof of concept, but it does mostly seem to work.

       THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT  ANY  EXPRESS  OR  IMPLIED  WARRANTIES,  INCLUDING,  WITHOUT
       LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

perl v5.40.1                                       2025-08-14                              MooseX::ArrayRef(3pm)

       MooseX::ArrayRef - blessed arrayrefs with Moose

       Moose, MooseX::GlobRef, MooseX::InsideOut.

         {
           package Local::Person;
           use Moose;
           has name => (
             is    => 'ro',
             isa   => 'Str',
           );
           __PACKAGE__->meta->make_immutable;
         }

         {
           package Local::Marriage;
           use MooseX::ArrayRef;
           has husband => (
             is    => 'ro',
             isa   => 'Local::Person',
           );
           has wife => (
             is    => 'ro',
             isa   => 'Local::Person',
           );
           __PACKAGE__->meta->make_immutable;
         }

         my $marriage = Local::Marriage->new(
           wife      => Local::Person->new(name => 'Alex'),
           husband   => Local::Person->new(name => 'Sam'),
         );

         use Data::Dumper;
         use Scalar::Util qw(reftype);
         print reftype($marriage), "\n";   # 'ARRAY'
         print Dumper($marriage);