NAME

       MooseX::MungeHas - munge your "has" (works with Moo, Moose and Mouse)

SYNOPSIS

          package Foo::Bar;

          use Moose;
          use MooseX::MungeHas "is_ro";

          has foo => ();             # read-only
          has bar => (is => "rw");   # read-write

DESCRIPTION

       MooseX::MungeHas alters the behaviour of the attributes of your Moo, Moose or Mouse based class. It
       manages to support all three because it doesn't attempt to do anything smart with metathingies; it simply
       installs a wrapper for "has" that munges the attribute specification hash before passing it on to the
       original "has" function.

       The following munges are always applied (simply because I can see no sensible reason why you would not
       want them to be).

       •   Implement "is => "rwp"" and "is => "lazy"" in Moose and Mouse.

           (These already work in Moo.)

       •   Implement "builder => 1", "clearer => 1", "predicate => 1", and "trigger => 1" in Moose and Mouse.

           (These already work in Moo.)

       •   Implement "builder => sub { ... }" in Moose and Mouse.

           (This already works in Moo.)

       •   Allow Moo to support "coerce => 0|1" for Type::Tiny type constraints. (Moo normally expects a coderef
           for the coercion.)

           (These already work in Moose and Mouse, and has actually been added to Moo as of version 1.006000.)

       •   Makes "has $name => sub { ... }" into a shortcut for:

              has $name => (is => "lazy", builder => sub { ... });

       •   Makes "has $name => $type_constraint" into a shortcut for:

              has $name => (isa => $type_constraint);

           (Assuming  that  $type_constraint is a blessed type constraint object a la Type::Tiny, MooseX::Types,
           etc.)

       •   Makes "lazy => sub { ... }" into a shortcut for:

               lazy    => 1,
               builder => sub { ... },

       When you import this module (i.e. "use MooseX::MungeHas") you can provide a list  of  additional  mungers
       you  want  it  to  apply.  These  may  be  provided  as coderefs, though for a few common, useful sets of
       behaviour, there are pre-defined shortcut strings.

          # "no_isa" is a pre-defined shortcut;
          # the other munger is a coderef.
          #
          use MooseX::MungeHas "no_isa", sub {
             # Make constructor ignore private attributes
             $_{init_arg} = undef if /^_/;
          };

       Within coderefs, the name of the attribute being processed is available  in  the  $_  variable,  and  the
       specification hash is available as %_.

       You may provide multiple coderefs.

       The following are the pre-defined shortcuts:

       "is_ro", "is_rw", "is_rwp", "is_lazy"
           These mungers supply defaults for the "is" option.

       "always_coerce"
           Automatically  provides  "coerce  =>  1"  if  the  type constraint provides coercions. (Unless you've
           explicitly specified "coerce => 0".)

       "always_required"
           Automatically provides "required =>  1"  unless  there  is  a  default  or  builder.  (Unless  you've
           explicitly specified "required => 0".)

       "no_isa"
           Switches off "isa" checks for attributes, unless they coerce.

       "simple_isa"
           Loosens  type constraints if they don't coerce, and if it's likely to make them significantly faster.
           (Loosening "Int" to "Num" won't speed it up.)

           Only works if you're using Type::Tiny constraints.

       Mungers provided as coderefs are executed after predefined ones, but are otherwise executed in the  order
       specified.

   Multiple Wrappers
       Since  version  0.007,  it  has  been  possible  to use MooseX::MungeHas to export multiple wrappers with
       different names:

          package Foo;
          use Moose;
          use MooseX::MungeHas {
             has_ro   => [ "is_ro", "always_coerce" ],
             has_rw   => [ "is_rw", "always_coerce" ],
          };

          has_ro "foo" => (required => 1);
          has_rw "bar";

       Note in the example above, MooseX::MungeHas has installed two brand  new  wrapped  "has"  functions  with
       different names, but it has left the standard "has" function unmolested.

       If you wanted to alter the standard function too, then you could use:

          package Foo;
          use Moose;
          use MooseX::MungeHas {
             has      => [          "always_coerce" ],
             has_ro   => [ "is_ro", "always_coerce" ],
             has_rw   => [ "is_rw", "always_coerce" ],
          };

          has_ro "foo" => (required => 1);
          has_rw "bar";

BUGS

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

SEE ALSO

       Moo, Mouse, Moose, MooseX::AttributeShortcuts, MooseX::InlineTypes, Type::Tiny::Manual.

       Similar:     MooseX::HasDefaults,     MooseX::Attributes::Curried,    MooseX::Attribute::Prototype    and
       MooseX::AttributeDefaults.

AUTHOR

       Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE

       This software is copyright (c) 2013-2014, 2017 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.

DISCLAIMER OF WARRANTIES

       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.36.0                                       2022-08-28                              MooseX::MungeHas(3pm)