Type::Tiny::Class(3) User Contributed Perl Documentation Type::Tiny::Class(3)

# [NAME](#NAME)

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

# [SYNOPSIS](#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](#STATUS)

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

# [DESCRIPTION](#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](#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](#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](#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)](#stringifies_to%28$constraint%29)

See Type::Tiny::ConstrainedObject.

[numifies\_to($constraint)](#numifies_to%28$constraint%29)

See Type::Tiny::ConstrainedObject.

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

See Type::Tiny::ConstrainedObject.

## [Exports](#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 )](#is_HTTPTiny%28)

[assert\_HTTPTiny( $value )](#assert_HTTPTiny%28)

[to\_HTTPTiny( $value )](#to_HTTPTiny%28)

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](#BUGS)

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

# [SEE ALSO](#SEE_ALSO)

Type::Tiny::Manual.

Type::Tiny.

Moose::Meta::TypeConstraint::Class.

# [AUTHOR](#AUTHOR)

Toby Inkster <tobyink@cpan.org>.

# [COPYRIGHT AND LICENCE](#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](#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.

2026-10-25 perl v5.44.0

---

Document: Type::Tiny::Class(3pm) from perl-type-tiny 2.010001-r4 (Chainguard OS)
Source: https://github.com/tobyink/p5-type-tiny