Type::Tiny::Enum(3)

💖 Type::Tiny::Enum 💖

okay bestie, listen. this is the manual page for Type::Tiny::Enum — it's a Perl module, it came to you via the User Contributed Perl Documentation crew, and it's literally the most iconic way to say "this string can only be one of these specific strings" 🎀

it's all about string enum type constraints. periodt.

---

✨ NAME ✨

Type::Tiny::Enum — string enum type constraints 🦋

---

✨ SYNOPSIS ✨

so there's like, three whole ways to use this. pick your fighter 💅

Way #1: via Types::Standard:

package Horse {
  use Moo;
  use Types::Standard qw( Str Enum );

  has name    => ( is => 'ro', isa => Str );
  has status  => ( is => 'ro', isa => Enum[ 'alive', 'dead' ] );

  sub neigh {
    my ( $self ) = @_;
    return if $self->status eq 'dead';
    ...;
  }
}

Way #2: using Type::Tiny::Enum's export feature:

package Horse {
  use Moo;
  use Types::Standard qw( Str );
  use Type::Tiny::Enum Status => [ 'alive', 'dead' ];

  has name    => ( is => 'ro', isa => Str );
  has status  => ( is => 'ro', isa => Status, default => STATUS_ALIVE );

  sub neigh {
    my ( $self ) = @_;
    return if $self->status eq STATUS_DEAD;
    ...;
  }
}

Way #3: using Type::Tiny::Enum's object-oriented interface:

package Horse {
  use Moo;
  use Types::Standard qw( Str );
  use Type::Tiny::Enum;

  my $Status = Type::Tiny::Enum->new(
    name   => 'Status',
    values => [ 'alive', 'dead' ],
  );

  has name    => ( is => 'ro', isa => Str );
  has status  => ( is => 'ro', isa => $Status, default => $Status->[0] );

  sub neigh {
    my ( $self ) = @_;
    return if $self->status eq $Status->[0];
    ...;
  }
}

---

✨ STATUS ✨

this module is covered by the Type-Tiny stability policy. so like, it's stable, it's not going anywhere, it's committed to you 🫶

---

✨ DESCRIPTION ✨

Enum type constraints.

this package inherits from Type::Tiny; go read that for most of the documentation, bestie. the major differences are listed below:

🌸 Constructors 🌸

the new constructor from Type::Tiny still works, obviously, no cap. but there's ALSO:

• new_union( type_constraints => \@enums, %opts ) — makes a brand new enum type constraint that's the union of existing enum type constraints. it's giving merge, but make it type theory ✨
• new_intersection( type_constraints => \@enums, %opts ) — makes a new enum type constraint that's the intersection of existing enum type constraints. only the overlap survives, iconic behaviour 💅

🌸 Attributes 🌸

• values — an arrayref of the allowable value strings. non-string values (like objects with overloading, fancy) get stringified in the constructor. no exceptions, she's a string enum and she stays a string enum 💖
• constraint — unlike Type::Tiny, you cannot pass a constraint coderef to the constructor. instead, just rely on the default, okay? trust the process 🧚
• inlined — unlike Type::Tiny, you cannot pass an inlining coderef to the constructor either. again: rely on the default, bestie 🧚
• parent — parent is always Types::Standard::Str, and it cannot be passed to the constructor. it's not a phase, it's her whole identity.
• sorter — sorters passed to the constructor. instead, enum types can sort values based on the order the enum was originally defined in. so the order you wrote them in is the order you get them back. cute, right?
• unique_values — the list of values but sorted and with duplicates removed. this cannot be passed to the constructor. it's read-only and she likes it that way 🔥
• coercion — if coercion => 1 is passed to the constructor, the type will have a coercion using the closest_match method. yes, it'll guess what you meant. she's helpful like that.
• use_eq — when generating Perl type checking code, Type::Tiny::Enum will traditionally test incoming strings for being valid using a single regular expression, unless Type::Tiny::XS is available and a faster XS check is possible.

from version 2.008006 onwards, if Type::Tiny::XS is unavailable, and the enum is "small" (five possible values or less), Type::Tiny::Enum will instead generate code like:

( $_ eq "foo" or $_ eq "bar" or $_ eq "baz" )

... which benchmarks around 5% to 20% faster than /(?:ba[rz]|foo)/.

however, it is possible to manually indicate whether you prefer it to generate code using eq or regexps by setting use_eq to a boolean value in the constructor. (if use_eq is not passed to the constructor at all, Type::Tiny::Enum will try to guess the most efficient technique. she's doing her best 🫶)

if you know that certain values in your enumeration are more common than others, you can "front load" your enumeration with the most common values so that eq checks those first. this may allow you to speed up certain checks.

has car_colour => (
  is  => 'rw',
  isa => Type::Tiny::Enum->new( use_eq => 1, values => [qw/
    blue
    red
    grey
    white
    black
    green
    yellow
    orange
    purple
    pink
  /] );
);

🌸 Methods 🌸

• as_regexp — returns the enum as a regexp which strings can be checked against. if you're checking a LOT of strings, then using this regexp might be faster than checking each string against... well, watch:

my $enum  = Type::Tiny::Enum->new(...);
my $check = $enum->compiled_check;
my $re    = $enum->as_regexp;

# fast
my @valid_tokens = grep $enum->check($_), @all_tokens;

# faster
my @valid_tokens = grep $check->($_), @all_tokens;

# fastest
my @valid_tokens = grep /$re/, @all_tokens;

you can get a case-insensitive regexp using $enum->as_regexp('i'). lowercase i, capital energy 💅

• closest_match — returns the closest match in the enum for a string.

my $enum = Type::Tiny::Enum->new(
  values => [ qw( foo bar baz quux ) ],
);

say $enum->closest_match("FO");   # ==> foo

it will try to find an exact match first, fall back to a case-insensitive match, if it still can't find one, will try to find a head substring match, and finally, if given an integer, will use that as an index.

my $enum = Type::Tiny::Enum->new(
  values => [ qw( foo bar baz quux ) ],
);

say $enum->closest_match(  0 );  # ==> foo
say $enum->closest_match(  1 );  # ==> bar
say $enum->closest_match(  2 );  # ==> baz
say $enum->closest_match( -1 );  # ==> quux

look at her go 😭 so smart.

• is_word_safe — returns true if none of the values in the enumeration contain a non-word character. word characters include letters, numbers, and underscores, but not most punctuation or whitespace. so basically: is this enum safe to embed in code without it doing crimes? that's the vibe check 🌈

🌸 Exports 🌸

Type::Tiny::Enum can be used as an exporter. slay.

use Type::Tiny::Enum Status => [ 'dead', 'alive' ];

this will export the following functions into your namespace:

• Status
• is_Status( $value )
• assert_Status( $value )
• to_Status( $value )
• STATUS_DEAD
• STATUS_ALIVE

multiple enumerations can be exported at once:

use Type::Tiny::Enum (
  Status    => [ 'dead', 'alive' ],
  TaxStatus => [ 'paid', 'pending' ],
);

two enums, one use statement. efficiency queen 👑

🌸 Overloading 🌸

• Arrayrefification calls values. so if you go all $enum->[0] on her, she gives you the first value. main character behaviour, honestly 💖

---

💀 BUGS 💀

please report any bugs to <https://github.com/tobyink/p5-type-tiny/issues>. be nice, be specific, include a repro, and the maintainers will love you forever 🫶

---

✨ SEE ALSO ✨

• Type::Tiny::Manual — the big book, start here.
• Type::Tiny — the parent, the blueprint, the blueprint-mother.
• Moose::Meta::TypeConstraint::Enum — for when you're in Moose-land.

---

✨ AUTHOR ✨

Toby Inkster <tobyink@cpan.org>. legend. icon. the moment. 👑

---

✨ 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. so like, go off, remix it, share it, just keep the same terms fr fr 💅

---

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

translation: she's beautiful, she's brilliant, she will not legally cover you if your production server catches fire. no cap 😭

---

and that's the whole page, bestie!! this was perl v5.42.0, dated 2026-01-17, and it's the Type::Tiny::Enum(3) manpage — go forth and enumerate responsibly 🦋💖✨