NAME

       Type::Tiny::Manual::UsingWithMoo - how to use Type::Tiny and Type::Library with Moo

SYNOPSIS

          {
             package Person;

             use Moo;
             use Types::Standard qw( Str Int );
             use Type::Utils qw( declare as where inline_as coerce from );

             has name => (
                is      => "ro",
                isa     => Str,
             );

             my $PositiveInt = declare
                as        Int,
                where     {  $_ > 0  },
                inline_as { "$_ =~ /^[0-9]\$/ and $_ > 0" };

             coerce $PositiveInt, from Int, q{ abs $_ };

             has age => (
                is      => "rwp",
                isa     => $PositiveInt,
                coerce  => $PositiveInt->coercion,
             );

             sub get_older {
                my $self = shift;
                my ($years) = @_;
                $PositiveInt->assert_valid($years);
                $self->_set_age($self->age + $years);
             }
          }

DESCRIPTION

       Type::Tiny is tested with Moo 1.001000 and above.

       Type::Tiny overloads "&{}". Moo supports using objects that overload "&{}" as "isa"
       constraints, so Type::Tiny objects can directly be used in "isa".

       Moo doesn't support "coerce => 1" but requires a coderef as a coercion.  However, again it
       supports using objects that overload "&{}", which Type::Coercion does, allowing "coerce =>
       $Type->coercion" to work.

       Type::Tiny hooks into Moo's HandleMoose interface to ensure that type constraints get
       inflated to Moose type constraints if and when Moo inflates your class to a full Moose
       class.

   Optimization
       The usual advice for optimizing type constraints applies: use type constraints which can
       be inlined whenever possible, and define coercions as strings rather than coderefs.

       Upgrading to Moo 1.002000 or above should provide a slight increase in speed for type
       constraints, as it allows them to be inlined into accessors and constructors.

       If creating your own type constraints using "Type::Tiny->new", then consider using
       Sub::Quote to quote the coderef; this allows you to take advantage of inlining without
       having to write your own inlining routines.

SEE ALSO

       For examples using Type::Tiny with Moo see the SYNOPSIS sections of Type::Tiny and
       Type::Library, and the files "moo.t" and "moo-coercion.t" and "moo-inflation.t" in the
       Type-Tiny test suite <https://bitbucket.org/tobyink/p5-type-tiny/src/tip/t>.

AUTHOR

       Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE

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