---
name: "Type::Tiny::Manual::UsingWithClassTiny"
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::Manual::UsingWithClassTiny"
---

# Type::Tiny::Manual::UsingWithClassTiny(3pm)

use of Type::Tiny with Class::Tiny

## NAME

Type::Tiny::Manual::UsingWithClassTiny - use of Type::Tiny with Class::Tiny

## MANUAL

Class::Tiny is an even-smaller-than-Moo class builder.

Let's translate the classic Horse class from Moo to Class::Tiny.

Moo:

```
  package Horse {
    use Moo;
    use Types::Standard qw( Str Num ArrayRef );
    use namespace::autoclean;

    has name       => ( is => 'ro', isa => Str, required => 1 );
    has gender     => ( is => 'ro', isa => Str );
    has age        => ( is => 'rw', isa => Num );
    has children   => (
      is       => 'ro',
      isa      => ArrayRef,
      default  => sub { return [] },
    );
  }
```

Class::Tiny:

```
  package Horse {
    use Class::Tiny qw( gender age ), {
      name     => sub { die "name is required"; },
      children => sub { return [] },
    };
    use Types::Standard qw( Str Num ArrayRef Dict Optional Slurpy Any Object );
    use Type::Params qw( signature_for );
    use namespace::autoclean;

    # type checks
    signature_for BUILD => (
      method => Object,
      named  => [
        name       => Str,
        gender     => Optional[Str],
        age        => Optional[Num],
        children   => Optional[ArrayRef],
        ()         => Slurpy[Any],
      ],
      fallback => 1,
    );
    signature_for [ 'name', 'gender', 'children' ] => (
      method     => Object,
      positional => [],
    );
    signature_for age => (
      method     => Object,
      positional => [ Optional[Num] ],
    );
  }
```

What's going on here?

Well, Class::Tiny, after it has built a new object, will do this:

```
  $self->BUILD($args);
```

(Technically, it calls `"BUILD"` not just for the current class, but for all parent classes too.) We can hook onto this in order to check type constraints for the constructor.

We use `"signature_for"` from Type::Params to wrap the original `"BUILD"` method (which doesn't exist, so `"fallback => 1"` will just assume an empty sub) with a type check for its arguments. The type check is just a **Dict** that checks the class's required and optional attributes and includes **Slurpy\[Any\]** at the end to be flexible for subclasses adding new attributes.

Then we wrap the `"name"`, `"gender"`, and `"children"` methods with checks to make sure they're only being called as getters, and we wrap `"age"`, allowing it to be called as a setter with a **Num**.

There are also a couple of CPAN modules that can help you out.

### Class::Tiny::ConstrainedAccessor

Class::Tiny::ConstrainedAccessor creates a `"BUILD"` and accessors that enforce Type::Tiny constraints.  Attribute types are passed to Class::Tiny::ConstrainedAccessor; attribute defaults are passed to Class::Tiny.

```
  package Horse {
    use Types::Standard qw( Str Num ArrayRef );
    use Class::Tiny::ConstrainedAccessor {
      name     => Str,
      gender   => Str,
      age      => Num,
      children => ArrayRef,
    };
    use Class::Tiny qw( gender age ), {
      name     => sub { die "name is required"; },
      children => sub { return [] },
    };
  }
```

### Class::Tiny::Antlers

Class::Tiny::Antlers provides Moose-like syntax for Class::Tiny, including support for `"isa"`.  You do not also need to use Class::Tiny itself.

```
  package Horse {
    use Class::Tiny::Antlers qw(has);
    use Types::Standard qw( Str Num ArrayRef );
    use namespace::autoclean;

    has name       => (
      is        => 'ro',
      isa       => Str,
      default   => sub { die "name is required" },
    );
    has gender     => ( is => 'ro',    isa => Str );
    has age        => ( is => 'rw',    isa => Num );
    has children   => (
      is        => 'ro',
      isa       => ArrayRef,
      default   => sub { return [] },
    );
  }
```

## NEXT STEPS

Here's your next step:

- •

  Type::Tiny::Manual::UsingWithOther

  Using Type::Tiny with Class::InsideOut, Params::Check, and Object::Accessor.

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