---
name: "MooX::Types::MooseLike::Base"
section: "3pm"
platform: "linux"
package: "perl-moox-types-mooselike"
version: "0.29-13"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/MooX::Types::MooseLike::Base"
---

# MooX::Types::MooseLike::Base(3pm)

A set of basic Moose-like types for Moo

## NAME

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

## SYNOPSIS

```
  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) },
  );
```

## DESCRIPTION

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.

## TYPES (1st class functions - return a coderef)

### Any

Any type (test is always true)

### Item

Synonymous with Any type

### Undef

A type that is not defined

### Defined

A type that is defined

### Bool

A boolean 1\|0 type

### Value

A non-reference type

### Ref

A reference type

### Str

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

### Num

A number type

### Int

An integer type

### ArrayRef

An ArrayRef (ARRAY) type

### HashRef

A HashRef (HASH) type

### CodeRef

A CodeRef (CODE) type

### RegexpRef

A regular expression reference type

### GlobRef

A glob reference type

### FileHandle

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

### Object

A type that is an object (think blessed)

## PARAMETERIZED TYPES

### Parameterizing Types With a Single Type

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

### Parameterizing Types With Multiple Types

*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']
  ],
```

### Parameterizing Types With (Multiple) Strings

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']
```

## 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

## AUTHOR

Mateu Hunter `"hunter@missoula.org"`

## THANKS

mst has provided critical guidance on the design

## COPYRIGHT

Copyright 2011-2015 Mateu Hunter

## LICENSE

You may distribute this code under the same terms as Perl itself.