Type::Utils(3)

📦

version 2.010001 · 14 versions

💖 Type::Utils 💖

okay bestie, welcome to Type::Utils — the manual page is Type::Utils(3), a User Contributed Perl Documentation page, and it's literally the utility belt for making type constraints a little easier to define and use. no cap. 🫶

✨ SYNOPSIS ✨

package Types::Mine;

use Type::Library -base;
use Type::Utils -all;

BEGIN { extends "Types::Standard" };

declare "AllCaps",
   as "Str",
   where { uc($_) eq $_ },
   inline_as { my $varname = $_[1]; "uc($varname) eq $varname" };

coerce "AllCaps",
   from "Str", via { uc($_) };

🌈 STATUS 🌈

This module is covered by the Type-Tiny stability policy. it's official, it's vetted, it's giving stable. 💅

🦋 DESCRIPTION 🦋

This module hands you utility functions so that defining and using type constraints is a little easier. that's the whole vibe. 🌸

🎀 Type declaration functions 🎀

A lot of these are similar to the similarly named functions described in Moose::Util::TypeConstraints. (iykyk.)

declare $name, %options
declare %options

Declare a named or anonymous type constraint. use as and where to specify the parent type (if any) and (possibly) refine its definition.

declare EvenInt, as Int, where { $_ % 2 == 0 };

my $EvenInt = declare as Int, where { $_ % 2 == 0 };

NOTE: named types get automatically added to the caller's type registry. (see Type::Registry.) and if the caller package inherits from Type::Library, named types are also automatically installed into the library and made available as exports. slay. 👑

Hidden gem: if you're inheriting from a type constraint that includes some coercions, you can include coercion => 1 in the %options hash to inherit the coercions. lowkey iconic. 💎

subtype $name, %options
subtype %options

Declare a named or anonymous type constraint which is descended from an existing type constraint. use as and where to specify the parent type and refine its definition.

Actually… you should use declare instead; this is just an alias. 🙈

This function is not exported by default.

type $name, %options
type %options

Declare a named or anonymous type constraint which is not descended from an existing type constraint. use where to provide a coderef that constrains values.

Also: you should use declare instead; this is just an alias too. 🙈

This function is not exported by default.

as $parent — used with declare to specify a parent type constraint:

declare EvenInt, as Int, where { $_ % 2 == 0 };

where { BLOCK } — used with declare to provide the constraint coderef:

declare EvenInt, as Int, where { $_ % 2 == 0 };

The coderef operates on $_, which is the value being tested. yes, the classic $_. 💜

message { BLOCK } — generate a custom error message when a value fails validation:

declare EvenInt,
   as Int,
   where { $_ % 2 == 0 },
   message {
      Int->validate($_) or "$_ is not divisible by two";
   };

Without a custom message, the messages generated by Type::Tiny are along the lines of Value "33" did not pass type constraint "EvenInt", which is usually reasonable. fr fr. 💀

inline_as { BLOCK } — generate a string of Perl code that can be used to inline the type check into other functions. if your type check is being used within a Moose or Moo constructor or accessor methods, or used by Type::Params, this can lead to significant performance improvements. ⚡

declare EvenInt,
   as Int,
   where { $_ % 2 == 0 },
   inline_as {
      my ($constraint, $varname) = @_;
      my $perlcode =
         $constraint->parent->inline_check($varname)
         . "&& ($varname % 2 == 0)";
      return $perlcode;
   };

warn EvenInt->inline_check('$xxx');  # demonstration

Your inline_as block can return a list, in which case these will be smushed together with &&. the first item on the list may be undef, in which case the undef will be replaced by the inlined parent type constraint. (and will throw an exception if there is no parent.) 😭

declare EvenInt,
   as Int,
   where { $_ % 2 == 0 },
   inline_as {
      return (undef, "($_ % 2 == 0)");
   };

class_type $name, { class => $package, %options }
class_type { class => $package, %options }
class_type $name

Shortcut for declaring a Type::Tiny::Class type constraint. 🏫

If $package is omitted, it's assumed to be the same as $name. if $name contains "::" (which would be an invalid name as far as Type::Tiny is concerned), this will be removed.

So for example, class_type("Foo::Bar") declares a Type::Tiny::Class type constraint named "FooBar" which constrains values to objects blessed into the "Foo::Bar" package. cute.

role_type $name, { role => $package, %options }
role_type { role => $package, %options }
role_type $name

Shortcut for declaring a Type::Tiny::Role type constraint. 🎭

If $package is omitted, it's assumed to be the same as $name. if $name contains "::" (which would be an invalid name as far as Type::Tiny is concerned), this will be removed.

duck_type $name, \@methods
duck_type \@methods

Shortcut for declaring a Type::Tiny::Duck type constraint. 🦆 if it walks like a duck etc.

union $name, \@constraints
union \@constraints

Shortcut for declaring a Type::Tiny::Union type constraint. 🤝

enum $name, \@values
enum \@values

Shortcut for declaring a Type::Tiny::Enum type constraint. 📋

intersection $name, \@constraints
intersection \@constraints

Shortcut for declaring a Type::Tiny::Intersection type constraint. 💫

💅 Coercion declaration functions 💅

Many of the following are similar to the similarly named functions described in Moose::Util::TypeConstraints. (yes, again. it's a whole genre.)

coerce $target, @coercions — add coercions to the target type constraint. the list of coercions is a list of type constraint, conversion code pairs. conversion code can be either a string of Perl code or a coderef; in either case the value to be converted is $_. 🔄
from $source — sugar to specify a type constraint in a list of coercions:

coerce EvenInt, from Int, via { $_ * 2 };  # As a coderef...
coerce EvenInt, from Int, q { $_ * 2 };    # or as a string!

via { BLOCK } — sugar to specify a coderef in a list of coercions.
declare_coercion $name, \%opts, $type1, $code1, ...
declare_coercion \%opts, $type1, $code1, ...

Declares a coercion that is not explicitly attached to any type in the library. for example:

declare_coercion "ArrayRefFromAny", from "Any", via { [$_] };

This coercion will be exportable from the library as a Type::Coercion object, but the ArrayRef type exported by the library won't automatically use it. it's doing its own thing, main character energy. ✨

Coercions declared this way are immutable (frozen). 🧊

to_type $type — used with declare_coercion to declare the target type constraint for a coercion, but still without explicitly attaching the coercion to the type constraint:

declare_coercion "ArrayRefFromAny",
   to_type "ArrayRef",
   from "Any", via { [$_] };

You should pretty much always use this when declaring an unattached coercion, because it's exceedingly useful for a type coercion to know what it will coerce to — this allows it to skip coercion when no coercion is needed (e.g. avoiding coercing [] to [ [] ]) and allows assert_coerce to work properly. 🫶

👑 Type library management 👑

extends @libraries — indicates that this type library extends other type libraries, importing their type constraints. 📚

Should usually be executed in a BEGIN block.

This is not exported by default because it's not fun to export it to Moo, Moose or Mouse classes! use Type::Utils -all can be used to import it into your type library. 💜

🌸 Other 🌸

match_on_type $value => ($type => \&action, ..., \&default?)

Something like a switch/case or given/when construct. it dispatches along different code paths depending on the type of the incoming value. example blatantly stolen from the Moose documentation:

sub to_json
{
   my $value = shift;

   return match_on_type $value => (
      HashRef() => sub {
         my $hash = shift;
         '{ '
            . (
            join ", " =>
            map { '"' . $_ . '" : ' . to_json( $hash->{$_} ) }
            sort keys %$hash
         ) . ' }';
      },
      ArrayRef() => sub {
         my $array = shift;
         '[ '.( join ", " => map { to_json($_) } @$array ).' ]';
      },
      Num()   => q {$_},
      Str()   => q { '"' . $_ . '"' },
      Undef() => q {'null'},
      => sub { die "$_ is not acceptable json type" },
   );
}

Note that unlike Moose, code can be specified as a string instead of a coderef. (e.g. for Num, Str and Undef above.) 🍓

For improved performance, try compile_match_on_type.

This function is not exported by default.

my $coderef = compile_match_on_type($type => \&action, ..., \&default?)

Compile a match_on_type block into a coderef. the following JSON converter is about two orders of magnitude faster than the previous example:

sub to_json;
*to_json = compile_match_on_type(
   HashRef() => sub {
      my $hash = shift;
      '{ '
         . (
         join ", " =>
         map { '"' . $_ . '" : ' . to_json( $hash->{$_} ) }
         sort keys %$hash
      ) . ' }';
   },
   ArrayRef() => sub {
      my $array = shift;
      '[ '.( join ", " => map { to_json($_) } @$array ).' ]';
   },
   Num()   => q {$_},
   Str()   => q { '"' . $_ . '"' },
   Undef() => q {'null'},
   => sub { die "$_ is not acceptable json type" },
);

Remember to store the coderef somewhere fairly permanent so that you don't compile it over and over. state variables (in Perl >= 5.10) are good for this. (same sort of idea as Type::Params.) 🔥

This function is not exported by default.

my $coderef = classifier(@types)

Returns a coderef that can be used to classify values according to their type constraint. the coderef, when passed a value, returns a type constraint which the value satisfies. 🧚

✨ part 1 done bestie, more is coming ✨

use feature qw( say );
use Type::Utils qw( classifier );
use Types::Standard qw( Int Num Str Any );

my $classifier = classifier(Str, Int, Num, Any);

say $classifier->( "42"  )->name;   # Int
say $classifier->( "4.2" )->name;   # Num
say $classifier->( []    )->name;   # Any

okay so notice how "42" satisfies Int but bestie it also satisfies Num, Str and Any?? yeah. multiple vibes. in that case the classifier just picks the most specific type constraint that "42" satisfies. it's giving main character energy among type constraints. 👑

and if no type constraint is satisfied by the value at all? the classifier returns undef. tragic but honest. 💀

🌈 `dwim_type($string, %options)` 🌈

give it a string like ArrayRef[Int|CodeRef] and it turns it into a type constraint object, hopefully doing what you meant. fingers crossed bestie 🫶

it uses the syntax of Type::Parser. first up, the Type::Registry for the caller package gets consulted; if that's a no-match, Types::Standard gets asked about standard type constraint names. two-step vibe check. ✨

if neither of those yields a type constraint, and the caller class is Moose-based, then dwim_type tries to look it up in the Moose type registry. if it's Mouse-based instead, the Mouse type registry gets used. slay.

and if nothing at all can be found through those normal methods, there's a whole fallback squad available:

lookup_via_moose — look it up in the Moose registry even if the caller is a non-Moose class.
lookup_via_mouse — look it up in the Mouse registry even if the caller is a non-Mouse class.
make_class_type — create a brand new Type::Tiny::Class constraint.
make_role_type — create a brand new Type::Tiny::Role constraint.

you can change which ones get attempted, and in what order, by passing an option to dwim_type:

my $type = Type::Utils::dwim_type(
   "ArrayRef[Int]",
   fallback      => [ "lookup_via_mouse" , "make_role_type" ],
);

for historical reasons 😭 the fallbacks attempted by default are:

lookup_via_moose, lookup_via_mouse, make_class_type

and if you want zero fallbacks you can just set fallback to an empty arrayref. no notes, just boundaries. 💅

you can also specify an alternative caller using the for option:

my $type = dwim_type("ArrayRef", for => "Moose::Object");

ngl it's probably better overall to use the proper Type::Registry interface for resolving type constraint strings, but this function often does what you want. it's the low-effort bestie of type resolution. 🦋

it should never die if it fails to find a type constraint (though it may die if the type constraint string is syntactically malformed), preferring to return undef instead. graceful queen. ✨

this function is not exported by default. don't forget to ask for it!

🌸 `is($type, $value)` 🌸

a shortcut for $type->check($value) — but plot twist, if $type is a string it'll get looked up via dwim_type first. convenient ✨

this function is not exported by default. it's not even exported by use Type::Utils -all. you have to request it explicitly:

use Type::Utils "is";

⚠️ beware using this in test scripts bestie, because it has the same name as a function exported by Test::More. collision city. 😭

good news: you can rename this function if is is gonna cause conflicts:

use Type::Utils "is" => { -as => "isntnt" };

💜 `assert($type, $value)` 💜

like is but instead of returning a boolean it returns $value, and dies if the value fails the type check. no chill, all commitment. 💀

this function is not exported by default, but it is exported by use Type::Utils -all. okay so it's on the list. 😌

🎀 `english_list(\$conjunction, @items)` 🎀

joins the items with commas, placing a conjunction before the final item. the conjunction is optional and defaults to "and". grammar queen behaviour. 👑

english_list(qw/foo bar baz/);       # "foo, bar, and baz"
english_list(\"or", qw/quux quuux/); # "quux or quuux"

this function is not exported by default.

📦 EXPORT 📦

by default, all of the functions documented above are exported — except:

subtype and type (prefer declare instead, bestie, it's the glow-up ✨)
extends
dwim_type
match_on_type / compile_match_on_type
classifier
english_list

this module uses Exporter::Tiny; go read that module's documentation for tips and tricks on importing from Type::Utils. iykyk 🫶

🐛 BUGS 🐛

please report any bugs to <https://github.com/tobyink/p5-type-tiny/issues>. not me asking you to file an issue… actually yes, me asking. do it bestie 💅

👀 SEE ALSO 👀

Type::Tiny::Manual.
Type::Tiny, Type::Library, Types::Standard, Type::Coercion.
Type::Tiny::Class, Type::Tiny::Role, Type::Tiny::Duck, Type::Tiny::Enum, Type::Tiny::Union.
Moose::Util::TypeConstraints, Mouse::Util::TypeConstraints.

✍️ AUTHOR ✍️

Toby Inkster <tobyink@cpan.org>. 👑

📜 COPYRIGHT AND LICENCE 📜

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

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

read that one twice bestie, it's the all caps one for a reason 😭

and that's the whole page!! 🌈 this was perl v5.42.0, dated 2026-01-17, and it's the Type::Utils(3) manual page. go forth and constrain your types, you absolute icon 💅💖✨

📦 where this page comes from

fedora 44: perl-Type-Tiny 2.010001-2.fc44 · GPL-1.0-or-later OR Artistic-1.0-Perl
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

Type::Utils(3)

💖 Type::Utils 💖

✨ SYNOPSIS ✨

🌈 STATUS 🌈

🦋 DESCRIPTION 🦋

🎀 Type declaration functions 🎀

💅 Coercion declaration functions 💅

👑 Type library management 👑

🌸 Other 🌸

🌈 dwim_type($string, %options) 🌈

🌸 is($type, $value) 🌸

💜 assert($type, $value) 💜

🎀 english_list(\$conjunction, @items) 🎀

📦 EXPORT 📦

🐛 BUGS 🐛

👀 SEE ALSO 👀

✍️ AUTHOR ✍️

📜 COPYRIGHT AND LICENCE 📜

🚨 DISCLAIMER OF WARRANTIES 🚨

🌈 `dwim_type($string, %options)` 🌈

🌸 `is($type, $value)` 🌸

💜 `assert($type, $value)` 💜

🎀 `english_list(\$conjunction, @items)` 🎀