Type::Tiny::Manual::UsingWithMite(3) User Contributed Perl Documentation Type::Tiny::Manual::UsingWithMite(3)

# [NAME](#NAME)

Type::Tiny::Manual::UsingWithMite - how to use Type::Tiny with Mite

# [MANUAL](#MANUAL)

Mite takes an unorthodox approach to object-oriented code. When you first start a project with Mite (which we'll assume is called Your::Project), Mite will create a module called Your::Project::Mite for you.

Then all your classes use code like:

```
   package Your::Project::Widget;
   
   use Your::Project::Mite -all;
   
   has name => (
      is => ro,
      isa => 'Str',
   );
   
   has id => (
      is => ro,
      isa => 'PositiveInt',
   );
   
   signature_for warble => (
      named => [
         foo   => 'Int',
         bar   => 'ArrayRef',
      ],
   );
   
   sub warble {
      my ( $self, $arg ) = @_;
      printf( "%s: %d\n", $self->name, $arg->foo );
      return;
   }
   
   1;
```

After writing or editing each class or role, you run the command "mite compile" and Mite will output a collection of compiled Perl classes which have no non-core dependencies (on Perl 5.14+. There are a couple of non-core dependencies on older versions of Perl.)

Attribute "isa" options are Type::Tiny type constraints expressed as strings. Mite looks them up during compilation using "dwim\_type" from Type::Utils, and pre-loads Types::Standard, Types::Common::String, and Types::Common::Numeric for you.

The "signature\_for" keyword is similar to the corresponding function in Type::Params. Again, note that types are expressed as strings and looked up using "dwim\_type".

Any types which are inlineable should work. If using coercion, any coercions which are inlineable should work.

## [Custom Types in Mite](#Custom_Types_in_Mite)

You can define your own type library (say, Your::Project::Types) using Type::Library as normal:

```
   package Your::Project::Types;
   
   use Type::Library
      -extends => [ 'Types::Standard', 'Types::Common::Numeric' ];
   
   __PACKAGE__->add_type(
      name    => 'Widget',
      parent  => InstanceOf['Your::Project::Widget'],
   )->coercion->add_type_coercions(
      HashRef, q{Your::Project::Widget->new($_)},
   );
   
   __PACKAGE__->make_immutable;
   
   1;
```

Now if your classes load Your::Project::Types they'll suddenly have a dependency on Type::Library, so you don't get that nice zero-dependency feeling. But you can add this to your ".mite/config" file:

```
   types: Your::Project::Types
```

Now Mite will know to load that type library at compile time, and will make those types available as stringy types everywhere.

## [Compiled Type Libraries](#Compiled_Type_Libraries)

It does look really pretty to not have to quote your type constraints:

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

One solution for that is Type::Library::Compiler.

Say you've created the custom type library above, you can use Type::Library::Compiler to compile it into a module called Your::Project::Types::Compiled, which just uses Exporter and doesn't rely on Type::Library or any other part of Type::Tiny.

Then your Widget class can use that:

```
   package Your::Project::Widget;
   
   use Your::Project::Mite -all;
   use Your::Project::Types::Compiled -types;
   
   has name => (
      is   => ro,
      isa  => Str,
   );
   
   has id => (
      is   => ro,
      isa  => PositiveInt,
   );
   
   signature_for warble => (
      named => [
         foo   => Int,
         bar   => ArrayRef,
      ],
   );
   
   sub warble {
      my ( $self, $arg ) = @_;
      printf( "%s: %d\n", $self->name, $arg->foo );
      return;
   }
   
   1;
```

The compiled type libraries are more limited than real type libraries. You can't, for example, do parameterized types with them. However, they still offer some cool features like:

```
   Foo->check( $value )     # a few basic methods like this
   is_Foo( $value )         # boolean checks
   assert_Foo( $value )     # assertions which die
   Foo | Bar                # unions!
```

This way you can write a project with object orientation, roles, method modifiers, type-checked attributes, type-checked signatures, and even coercion, with no non-core dependencies! (The tools like Mite and Type::Library::Compiler are only needed by the developer, not the end user.)

# [NEXT STEPS](#NEXT_STEPS)

Here's your next step:

•

Type::Tiny::Manual::UsingWithClassTiny

Including how to Type::Tiny in your object's "BUILD" method, and third-party shims between Type::Tiny and Class::Tiny.

# [AUTHOR](#AUTHOR)

Toby Inkster <tobyink@cpan.org>.

# [COPYRIGHT AND LICENCE](#COPYRIGHT_AND_LICENCE)

This software is copyright (c) 2022-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-06-28 perl v5.42.2

---

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