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] );
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.
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__);
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!"
Inflates the type to a Moose type. Requires Moose.
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.
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>