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.

