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

NAME SYNOPSIS DESCRIPTION FUNCTIONS register_types exception_message inflate_type SEE ALSO AUTHOR CONTRIBUTORS COPYRIGHT LICENSE

NAME

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

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__);