---
name: "MooX::Types::MooseLike"
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"
---

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

some Moosish types and a type builder

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