NAME

       MooX::Types::MooseLike - some Moosish types and a type builder

SYNOPSIS

         package MyApp::Types;
         use MooX::Types::MooseLike;
         use base qw(Exporter);
         our @EXPORT_OK = ();

         # Define some types
         my $defs = [{
           name => 'MyType',
           test => sub { predicate($_[0]) },
           message => sub { "$_[0] is not the type we want!" }
         },
         {
           name => 'VarChar',
           test => sub {
             my ($value, $param) = @_;
             length($value) <= $param;
           },
           message => sub { "$_[0] is too large! It should be less than or equal to $_[1]." }
         }];

         # Make the types available - this adds them to @EXPORT_OK automatically.
         MooX::Types::MooseLike::register_types($defs, __PACKAGE__);

         ...

         # Somewhere in code that uses the type
         package MyApp::Foo;
         use Moo;
         use MyApp::Types qw(MyType VarChar);

         has attribute => (
           is  => 'ro',
           isa => MyType,
         );

         has string => (
           is  => 'ro',
           isa => VarChar[25]
         );

DESCRIPTION

       This module provides a possibility to build your own set of Moose-like types. These custom
       types can then be used to describe fields in Moo-based classes.

       See MooX::Types::MooseLike::Base for a list of available base types.  Its source also
       provides an example of how to build base types, along with both parameterizable and non-
       parameterizable.

FUNCTIONS

   register_types
       register_types( types, package, moose_namespace )

       Install the given types within the package. This makes the types automatically exportable
       by adding them to @EXPORT_OK of the package. Types are expected to be an array ref where
       every type is of the following format:

         {
           name            => 'MyType',
           test            => sub { check_the_value_somehow($_[0]) },
           message         => sub { "$_[0] is not the type we want!" },
           subtype_of      => 'SomeParentType',           # Optional
           from            => 'Some::Parent::CoolTypes',  # Optional
           parameterizable => sub { ... },                # Optional
           inflate         => sub { ... },                # Optional
         }

       A type can be declared with a reference (subtype_of) to some previously declared type. In
       this case the new type will inherit the behaviour of the referenced type.

       The referenced type can come either from the same package or from a third party package:

         MooX::Types::MooseLike::register_types([{
           name       => 'GreaterThan10',
           subtype_of => 'Int',
           from       => 'MooX::Types::MooseLike::Base',
           test       => sub { $_[0] > 10 },
           message    => sub { 'not greater than 10' },
         }], __PACKAGE__);

         MooX::Types::MooseLike::register_types([{
           name       => 'Between10And20',
           subtype_of => 'GreaterThan10',
           from       => __PACKAGE__,
           test       => sub { $_[0] < 20 },
           message    => sub { 'not an integer between 10 and 20' },
         }], __PACKAGE__);

         MooX::Types::MooseLike::register_types([{
           name       => 'Between10And30',
           subtype_of => GreaterThan10(),
           test       => sub { $_[0] < 30 },
           message    => sub { 'not an integer between 10 and 30' },
         }], __PACKAGE__);

   exception_message
       exception_message( value, part_of_the_exception_string )

       Helper function to be used in a type definition:

         {
           ...
           message => sub { return exception_message($_[0], 'a HashRef' },
           ...
         }

       In the event of <value> mismatching the type constraints it produces the message:

         "<value> is not a HashRef!"

   inflate_type
       inflate_type( coderef )

       Inflates the type to a Moose type. Requires Moose.

SEE ALSO

       MooX::Types::MooseLike::Numeric - an example of building subtypes.

       MooX::Types::SetObject - an example of building parameterized types.

       MooX::Types::MooseLike::Email, MooX::Types::MooseLike::DateTime

       Type::Tiny - another implementation of type constraints. Compatible with Moo, Moose and
       Mouse.

AUTHOR

       mateu - Mateu X. Hunter (cpan:MATEU) <hunter@missoula.org>

CONTRIBUTORS

       mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>

       Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>

       Matt Phillips (cpan:MATTP) <mattp@cpan.org>

       Arthur Axel fREW Schmidt (cpan:FREW) <frioux@gmail.com>

       Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>

       Graham Knop (cpan:HAARG) <haarg@cpan.org>

       Dmitry Matrosov (cpan:AMIDOS) <amidos@amidos.ru>

COPYRIGHT

       Copyright (c) 2011-2015 the MooX::Types::MooseLike "AUTHOR" and
        "CONTRIBUTORS" as listed above.

LICENSE

       This library is free software and may be distributed under the same terms as perl itself.