---
name: "Type::Tiny::Class"
section: "3pm"
platform: "linux"
package: "perl-type-tiny"
version: "2.010001-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/Type::Tiny::Class"
---

# Type::Tiny::Class(3pm)

type constraints based on the "isa" method

## NAME

Type::Tiny::Class - type constraints based on the "isa" method

## SYNOPSIS

Using via Types::Standard:

```
  package Local::Horse {
    use Moo;
    use Types::Standard qw( Str InstanceOf );

    has name => (
      is       => 'ro',
      isa      => Str,
    );

    has owner => (
      is       => 'ro',
      isa      => InstanceOf[ 'Local::Person' ],
      default  => sub { Local::Person->new },
    );
  }
```

Using Type::Tiny::Class's export feature:

```
  package Local::Horse {
    use Moo;
    use Types::Standard qw( Str );
    use Type::Tiny::Class 'Local::Person';

    has name => (
      is       => 'ro',
      isa      => Str,
    );

    has owner => (
      is       => 'ro',
      isa      => LocalPerson,
      default  => sub { LocalPerson->new },
    );
  }
```

Using Type::Tiny::Class's object-oriented interface:

```
  package Local::Horse {
    use Moo;
    use Types::Standard qw( Str );
    use Type::Tiny::Class;

    my $Person = Type::Tiny::Class->new( class => 'Local::Person' );

    has name => (
      is       => 'ro',
      isa      => Str,
    );

    has owner => (
      is       => 'ro',
      isa      => $Person,
      default  => sub { $Person->new },
    );
  }
```

Using Type::Utils's functional interface:

```
  package Local::Horse {
    use Moo;
    use Types::Standard qw( Str );
    use Type::Utils;

    my $Person = class_type 'Local::Person';

    has name => (
      is       => 'ro',
      isa      => Str,
    );

    has owner => (
      is       => 'ro',
      isa      => $Person,
      default  => sub { $Person->new },
    );
  }
```

## STATUS

This module is covered by the Type-Tiny stability policy.

## DESCRIPTION

Type constraints of the general form `"{ $_->isa("Some::Class") }"`.

This package inherits from Type::Tiny; see that for most documentation. Major differences are listed below:

### Constructor

- "new"

  When the constructor is called on an *instance* of Type::Tiny::Class, it passes the call through to the constructor of the class for the constraint. So for example:

  ```
     my $type = Type::Tiny::Class->new(class => "Foo::Bar");
     my $obj  = $type->new(hello => "World");
     say ref($obj);   # prints "Foo::Bar"
  ```

  This little bit of DWIM was borrowed from MooseX::Types::TypeDecorator, but Type::Tiny doesn't take the idea quite as far.

### Attributes

- "class"

  The class for the constraint.

- "constraint"

  Unlike Type::Tiny, you *cannot* pass a constraint coderef to the constructor. Instead rely on the default.

- "inlined"

  Unlike Type::Tiny, you *cannot* pass an inlining coderef to the constructor. Instead rely on the default.

- "parent"

  Parent is automatically calculated, and cannot be passed to the constructor.

### Methods

- "plus\_constructors($source, $method\_name)"

  Much like `"plus_coercions"` but adds coercions that go via a constructor. (In fact, this is implemented as a wrapper for `"plus_coercions"`.)

  Example:

  ```
     package MyApp::Minion;

     use Moose; extends "MyApp::Person";

     use Types::Standard qw( HashRef Str );
     use Type::Utils qw( class_type );

     my $Person = class_type({ class => "MyApp::Person" });

     has boss => (
        is     => "ro",
        isa    => $Person->plus_constructors(
           HashRef,     "new",
           Str,         "_new_from_name",
        ),
        coerce => 1,
     );

     package main;

     MyApp::Minion->new(
        ...,
        boss => "Bob",  ## via MyApp::Person->_new_from_name
     );

     MyApp::Minion->new(
        ...,
        boss => { name => "Bob" },  ## via MyApp::Person->new
     );
  ```

  Because coercing `"HashRef"` via constructor is a common desire, if you call `"plus_constructors"` with no arguments at all, this is the default.

  ```
     $classtype->plus_constructors(HashRef, "new")
     $classtype->plus_constructors()  ## identical to above
  ```

  This is handy for Moose/Mouse/Moo-based classes.

- stringifies\_to($constraint)

  See Type::Tiny::ConstrainedObject.

- numifies\_to($constraint)

  See Type::Tiny::ConstrainedObject.

- "with\_attribute\_values($attr1 =\> $constraint1, ...)"

  See Type::Tiny::ConstrainedObject.

### Exports

Type::Tiny::Class can be used as an exporter.

```
  use Type::Tiny::Class 'HTTP::Tiny';
```

This will export the following functions into your namespace:

- "HTTPTiny"

  - is\_HTTPTiny( $value )

  - assert\_HTTPTiny( $value )

  - to\_HTTPTiny( $value )

  You will also be able to use `"HTTPTiny->new(...)"` as a shortcut for `"HTTP::Tiny->new(...)"`.

Multiple types can be exported at once:

```
  use Type::Tiny::Class qw( HTTP::Tiny LWP::UserAgent );
```

## BUGS

Please report any bugs to \<https://github.com/tobyink/p5-type-tiny/issues\>.

## SEE ALSO

Type::Tiny::Manual.

Type::Tiny.

Moose::Meta::TypeConstraint::Class.

## AUTHOR

Toby Inkster \<tobyink@cpan.org\>.

## COPYRIGHT AND LICENCE

This software is copyright (c) 2013-2014, 2017-2025 by Toby Inkster.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

## DISCLAIMER OF WARRANTIES

THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.