MooX::Types::MooseLike::Base(3) User Contributed Perl Documentation MooX::Types::MooseLike::Base(3)

MooX::Types::MooseLike::Base - A set of basic Moose-like types for Moo

package MyPackage;
use Moo;
use MooX::Types::MooseLike::Base qw(:all);

has "beers_by_day_of_week" => (
    isa => HashRef
);

has "current_BAC" => (
    isa => Num
);

# Also supporting is_$type.  For example, is_Int() can be used as follows
has 'legal_age' => (
    is => 'ro',
    isa => sub { die "$_[0] is not of legal age"
                 unless (is_Int($_[0]) && $_[0] > 17) },
);

Moo attributes (like Moose) have an 'isa' property. This module provides some basic types for this property. One can import all types with ':all' tag or import a list of types like:

use MooX::Types::MooseLike::Base qw/HashRef ArrayRef/;

so one could then declare some attributes like:

has 'contact' => (
  is => 'ro',
  isa => HashRef,
);
has 'guest_list' => (
  is => 'ro',
  isa => ArrayRef[HashRef],
);

These types provide a check that the contact attribute is a "hash" reference, and that the guest_list is an "array of hash" references.

Any type (test is always true)

Synonymous with Any type

A type that is not defined

A type that is defined

A boolean 1|0 type

A non-reference type

A reference type

A non-reference type where a reference to it is a SCALAR

A number type

An integer type

An ArrayRef (ARRAY) type

A HashRef (HASH) type

A CodeRef (CODE) type

A regular expression reference type

A glob reference type

A type that is either a builtin perl filehandle or an IO::Handle object

A type that is an object (think blessed)

The following types can be parameterized with other types.

ArrayRef

For example, ArrayRef[HashRef]

HashRef

ScalarRef

Maybe

For example, Maybe[Int] would be an integer or undef

AnyOf

Check if the attribute is any of the listed types (think union). Takes a list of types as the argument, for example:

isa => AnyOf[Int, ArrayRef[Int], HashRef[Int]]

Note: AnyOf is passed an ArrayRef[CodeRef]

AllOf

Check if the attribute is all of the listed types (think intersection). Takes a list of types as the argument. For example:

isa => AllOf[
  InstanceOf['Human'],
  ConsumerOf['Air'],
  HasMethods['breath', 'dance']
],

In addition, we have some parameterized types that take string arguments.

InstanceOf

Check if the attribute is an object instance of one or more classes. Uses "blessed" and "isa" to do so. Takes a list of class names as the argument. For example:

isa => InstanceOf['MyClass','MyOtherClass']

Note: InstanceOf is passed an ArrayRef[Str]

ConsumerOf

Check if the attribute is blessed and consumes one or more roles. Uses "blessed" and "does" to do so. Takes a list of role names as the arguments. For example:

isa => ConsumerOf['My::Role', 'My::AnotherRole']

HasMethods

Check if the attribute is blessed and has one or more methods. Uses "blessed" and "can" to do so. Takes a list of method names as the arguments. For example:

isa => HasMethods[qw/postulate contemplate liberate/]

Enum

Check if the attribute is one of the enumerated strings. Takes a list of possible string values. For example:

isa => Enum['rock', 'spock', 'paper', 'lizard', 'scissors']

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

Mateu Hunter "hunter@missoula.org"

mst has provided critical guidance on the design

Copyright 2011-2015 Mateu Hunter

You may distribute this code under the same terms as Perl itself.
2020-06-21 perl v5.32.0