Types::Standard(3)

📦

version 2.010001 · 14 versions

💖 NAME 💖

Bestie, this is Types::Standard(3) — the bundled set of built-in types for Type::Tiny. No cap, it's the type library that's always in your corner. 🫶

✨ SYNOPSIS ✨

Okay so here's the whole plot in one go. It's giving "I know it's a lot, but trust me, it slays." 🌸

use v5.36;

package Horse {
  use Moo;
  use Types::Standard qw( Str Int Enum ArrayRef Object );
  use Type::Params qw( signature_for );
  use namespace::autoclean;

  has name => (
    is       => 'ro',
    isa      => Str,
    required => 1,
  );

  has gender => (
    is       => 'ro',
    isa      => Enum[qw( f m )],
  );

  has age => (
    is       => 'rw',
    isa      => Int->where( '$_ >= 0' ),
  );

  has children => (
    is       => 'ro',
    isa      => ArrayRef[Object],
    default  => sub { return [] },
  );

  # method signature
  signature_for add_child => (
    method     => Object,
    positional => [ Object ],
  );

  sub add_child ( $self, $child ) {
    push $self->children->@*, $child;
    return $self;
  }
}

package main;

my $boldruler = Horse->new(
  name    => "Bold Ruler",
  gender  => 'm',
  age     => 16,
);

my $secretariat = Horse->new(
  name    => "Secretariat",
  gender  => 'm',
  age     => 0,
);

$boldruler->add_child( $secretariat );

use Types::Standard qw( is_Object assert_Object );

# is_Object($thing) returns a boolean
my $is_it_an_object = is_Object $boldruler;

# assert_Object($thing) returns $thing or dies
say assert_Object($boldruler)->name;  # says "Bold Ruler"

🌈 STATUS 🌈

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

🦋 DESCRIPTION 🦋

This documents the details of the Types::Standard type library. If you're new, Type::Tiny::Manual is a better starting place. Periodt.

Type::Tiny bundles a few types which seem to be useful. Iconic.

🐴 Moose-like 🐴

The following types are similar to those described in Moose::Util::TypeConstraints. Vibe check passed.

Any — Absolutely any value passes this type constraint (even undef). Literally anything. 💀
Item — Essentially the same as Any. All other type constraints in this library inherit directly or indirectly from Item. So it's the main character ancestor. 👑
Bool — Values that are reasonable booleans. Accepts 1, 0, the empty string and undef.

Other customers also bought: BoolLike from Types::TypeTiny.

Maybe[`a] — Given another type constraint, also accepts undef. For example, Maybe[Int] accepts all integers plus undef. Flexible queen.
Undef — Only undef passes this type constraint. Only. 😭
Defined — Only undef fails this type constraint. So basically "not undef". 🙈
Value — Any defined, non-reference value. Simple. Clean. Slay.
Str — Any string.

(The only difference between Value and Str is that the former accepts typeglobs and vstrings.) iykyk

Other customers also bought: StringLike from Types::TypeTiny.

Notice: future versions of Types::Standard might introduce coercions to Str from HasMethods['__TO_STRING__'] and from StringLike. Keep that in mind, bestie.

Num — See LaxNum and StrictNum below. They're coming, don't worry.
Int — An integer; that is a string of digits 0 to 9, optionally prefixed with a hyphen-minus character. Expect inconsistent results for dualvars, and numbers too high (or negative numbers too low) for Perl to safely represent as an integer. So like, careful with the huge ones. 😭
ClassName — The name of a loaded package. The package must have @ISA or $VERSION defined, or must define at least one sub to be considered a loaded package. Loaded and legendary.
RoleName — Like ClassName, but the package must not define a method called "new". This is subtly different from Moose's type constraint of the same name; let me know if this causes you any problems. (I can't promise I'll change anything though.) lol okay periodt
Ref[`a] — Any defined reference value, including blessed objects. Unlike Moose, Ref is a parameterized type, allowing Scalar::Util::reftype checks, a la

Ref["HASH"]  # hashrefs, including blessed hashrefs

Blessed hashrefs are still hashrefs, bestie.

ScalarRef[`a] — A value where "ref($value) eq "SCALAR" or ref($value) eq "REF"". If parameterized, the referred value must pass the additional constraint. For example, ScalarRef[Int] must be a reference to a scalar which holds an integer value. Pointing at an integer? Valid.
ArrayRef[`a] — A value where "ref($value) eq "ARRAY"". If parameterized, the elements of the array must pass the additional constraint. For example, ArrayRef[Num] must be a reference to an array of numbers. As an extension to Moose's ArrayRef type, a minimum and maximum array length can be given:

ArrayRef[CodeRef, 1]        # ArrayRef of at least one CodeRef
ArrayRef[FileHandle, 0, 2]  # ArrayRef of up to two FileHandles
ArrayRef[Any, 0, 100]       # ArrayRef of up to 100 elements

Other customers also bought: ArrayLike from Types::TypeTiny.

Notice: future versions of Types::Standard might introduce coercions to ArrayRef from HasMethods['__TO_ARRAYREF__'] and from ArrayLike. Future tea.

HashRef[`a] — A value where "ref($value) eq "HASH"". If parameterized, the values of the hash must pass the additional constraint. For example, HashRef[Num] must be a reference to an hash where the values are numbers. The hash keys are not constrained, but Perl limits them to strings; see Map below if you need to further constrain the hash values. Keys are just strings, sorry.

Other customers also bought: HashLike from Types::TypeTiny.

Notice: future versions of Types::Standard might introduce coercions to HashRef from HasMethods['__TO_HASHREF__'] and from HashLike. Stay tuned.

CodeRef — A value where "ref($value) eq "CODE"". Code refs are the moment.

Other customers also bought: CodeLike from Types::TypeTiny.

Notice: future versions of Types::Standard might introduce coercions to CodeRef from HasMethods['__TO_CODEREF__'] and from CodeLike. Future vibes.

RegexpRef — A reference where re::is_regexp($value) is true, or a blessed reference where "$value->isa("Regexp")" is true. Regex girlies rise.
GlobRef — A value where "ref($value) eq "GLOB"". Globs gonna glob.
FileHandle — A file handle. Open for business.
Object — A blessed object.

(This also accepts regexp refs.) Bougie and blessed.

🧸 Structured 🧸

Okay, so I stole some ideas from MooseX::Types::Structured. Not me being a little thief. 💅

Map[`k, `v] — Similar to HashRef but parameterized with type constraints for both the key and value. The constraint for keys would typically be a subtype of Str. Keys and values both getting checked.
Tuple[...] — Subtype of ArrayRef, accepting a list of type constraints for each slot in the array. Tuple[Int, HashRef] would match "[1, {}]" but not "[{}, 1]". Order matters, bestie.
Dict[...] — Subtype of HashRef, accepting a list of type constraints for each slot in the hash. For example Dict[name => Str, id => Int] allows "{ name => "Bob", id => 42 }". Named slots, slay.
Optional[`a] — Used in conjunction with Dict and Tuple to specify slots that are optional and may be omitted (but not necessarily set to an explicit undef). Dict[name => Str, id => Optional[Int]] allows "{ name => "Bob" }" but not "{ name => "Bob", id => "BOB" }". Optional but not lawless.

Note that any use of Optional[`a] outside the context of parameterized Dict and Tuple type constraints makes little sense, and its behaviour is undefined. (An exception: it is used by Type::Params for a similar purpose to how it's used in Tuple.) Don't do it. Seriously.

This module also exports a Slurpy parameterized type, which can be used as follows. Slurpy slurpy slurp.

It can cause additional trailing values in a Tuple to be slurped into a structure and validated. For example, slurping into an arrayref:

my $type = Tuple[ Str, Slurpy[ ArrayRef[Int] ] ];

$type->( ["Hello"] );                # ok
$type->( ["Hello", 1, 2, 3] );       # ok
$type->( ["Hello", [1, 2, 3]] );     # not ok

Or into a hashref:

my $type2 = Tuple[ Str, Slurpy[ Map[Int, RegexpRef] ] ];

$type2->( ["Hello"] );                               # ok
$type2->( ["Hello", 1, qr/one/i, 2, qr/two/] );      # ok

It can cause additional values in a Dict to be slurped into a hashref and validated:

my $type3 = Dict[ values => ArrayRef, Slurpy[ HashRef[Str] ] ];

$type3->( { values => [] } );                        # ok
$type3->( { values => [], name => "Foo" } );         # ok
$type3->( { values => [], name => [] } );            # not ok

In either Tuple or Dict, Slurpy[Any] can be used to indicate that additional values are acceptable, but should not be constrained in any way. Accepting, not stressing.

Slurpy[Any] is an optimized code path. Although the following are essentially equivalent checks, the former should run a lot faster:

Tuple[ Int, Slurpy[Any] ]
Tuple[ Int, Slurpy[ArrayRef] ]

A function slurpy($type) is also exported which was historically how slurpy types were created. Old school, still iconic.

Outside of Dict and Tuple, Slurpy[Foo] should just act the same as Foo. But don't do that. Just don't. 🙈

🎀 Objects 🎀

Okay, so I stole some ideas from MooX::Types::MooseLike::Base. Again, not me being a thief. 💅

InstanceOf[`a] — Shortcut for a union of Type::Tiny::Class constraints. InstanceOf["Foo", "Bar"] allows objects blessed into the "Foo" or "Bar" classes, or subclasses of those. Given no parameters, just equivalent to Object. Union energy.
ConsumerOf[`a] — Shortcut for an intersection of Type::Tiny::Role constraints. ConsumerOf["Foo", "Bar"] allows objects where "$o->DOES("Foo")" and "$o->DOES("Bar")" both return true. Given no parameters, just equivalent to Object. Intersection realness.
HasMethods[`a] — Shortcut for a Type::Tiny::Duck constraint. HasMethods["foo", "bar"] allows objects where "$o->can("foo")" and "$o->can("bar")" both return true. Given no parameters, just equivalent to Object. Duck typing, but make it type library.

👑 More 👑

There are a few other types exported by this module: Surprise, bestie.

Overload[`a] — With no parameters, checks that the value is an overloaded object. Can be given one or more string parameters, which are specific operations to check are overloaded. For example, the following checks for objects which overload addition and subtraction.

Overload["+", "-"]

Math girlies, this one's for you.

Tied[`a] — A reference to a tied scalar, array or hash. Can be parameterized with a type constraint which will be applied to the object returned by the tied() function. As a convenience, can also be parameterized with a string, which will be inflated to a Type::Tiny::Class.

use Types::Standard qw(Tied);
use Type::Utils qw(class_type);

my $My_Package = class_type { class => "My::Package" };

tie my %h, "My::Package";
\%h ~~ Tied;                   # true
\%h ~~ Tied[ $My_Package ];    # true
\%h ~~ Tied["My::Package"];    # true

tie my $s, "Other::Package";
\$s ~~ Tied;                   # true
$s  ~~ Tied;                   # false !!

bestie look at that last one. \$s ~~ Tied is true but $s ~~ Tied is false. The type check is looking at the reference, not at whatever is inside it, and that trips people up constantly. 🙈

So if you genuinely need to check that something is a reference to a tied hash specifically, you build an intersection, like:

use Types::Standard qw( Tied HashRef );

my $TiedHash = (Tied) & (HashRef);

tie my %h, "My::Package";
tie my $s, "Other::Package";

\%h ~~ $TiedHash;     # true
\$s ~~ $TiedHash;     # false

periodt, that's the move. 💅

StrMatch[a] — a string that matches a regular expression. obsessed, honestly:

declare "Distance",
   as StrMatch[ qr{^([0-9]+)\s*(mm|cm|m|km)$} ];

You can optionally provide a type constraint for the array of subexpressions too:

declare "Distance",
   as StrMatch[
      qr{^([0-9]+)\s*(.+)$},
      Tuple[
         Int,
         enum(DistanceUnit => [qw/ mm cm m km /]),
      ],
   ];

And here's one using Regexp::Common, because why not:

package Local::Host {
   use Moose;
   use Regexp::Common;
   has ip_address => (
      is         => 'ro',
      required   => 1,
      isa        => StrMatch[qr/^$RE{net}{IPv4}$/],
      default    => '127.0.0.1',
   );
}

Heads up: on certain versions of Perl, type constraints of the forms StrMatch[qr/../ and StrMatch[qr/\A..\z/ with any number of intervening dots can be optimized to simple length checks. Cute, right?

Enum[a] — as per MooX::Types::MooseLike::Base:

has size => (
   is     => "ro",
   isa    => Enum[qw( S M L XL XXL )],
);

You can enable coercion by passing \1 before the list of values. yes, a backslash-one, it's giving chaos but it works:

has size => (
   is     => "ro",
   isa    => Enum[ \1, qw( S M L XL XXL ) ],
   coerce => 1,
);

This will use the closest_match method in Type::Tiny::Enum to coerce closely matching strings. slay. ✨

OptList — an arrayref of arrayrefs in the style of Data::OptList output. that's it, that's the whole vibe.
LaxNum, StrictNum — okay so in Moose 2.09, the Num type constraint implementation got swapped out: it stopped being a wrapper around Scalar::Util's looks_like_number function and became a stricter regexp instead (which disallows things like "-Inf" and "Nan", fyi).

Types::Standard ships both implementations. LaxNum is measurably faster. no cap.

The Num type constraint is currently an alias for LaxNum unless you set the PERL_TYPES_STANDARD_STRICTNUM environment variable to true before loading Types::Standard, in which case it becomes an alias for StrictNum. The constant Types::Standard::STRICTNUM can be used to check if Num is being strict.

Most people should probably use Num or StrictNum. Don't explicitly use LaxNum unless you specifically need an attribute which will accept things like "Inf". bestie, you've been warned. 💀

CycleTuple[a] — similar to Tuple, but cyclical.

CycleTuple[Int, HashRef]

will allow [1,{}] and [1,{},2,{}] but disallow [1,{},2] and [1,{},2,"not a hashref"]. ate.

I think you understand CycleTuple already. 💅

Currently Optional and Slurpy parameters are forbidden. There are fairly limited use cases for them, and it's not exactly clear what they should mean.

The following is an efficient way of checking for an even-sized arrayref:

CycleTuple[Any, Any]

The following is an arrayref which would be suitable for coercing to a hashref:

CycleTuple[Str, Any]

All the examples so far have used two parameters, but the following is also a possible CycleTuple:

CycleTuple[Str, Int, HashRef]

This will be an arrayref where the 0th, 3rd, 6th, etc values are strings, the 1st, 4th, 7th, etc values are integers, and the 2nd, 5th, 8th, etc values are hashrefs. it just keeps going and going and honestly? iconic. 🦋

✨ Coercions ✨

Most of the types in this type library have no coercions. The exception is Bool as of Types::Standard 1.003_003, which coerces from Any via !!$_. main character energy, honestly. 👑

Some standalone coercions may be exported. These can be combined with type constraints using the plus_coercions method.

MkOpt — a coercion from ArrayRef, HashRef or Undef to OptList. Example usage in a Moose attribute:

use Types::Standard qw( OptList MkOpt );

has options => (
   is     => "ro",
   isa    => OptList->plus_coercions( MkOpt ),
   coerce => 1,
);

Split[a] — split a string on a regexp.

use Types::Standard qw( ArrayRef Str Split );

has name => (
   is     => "ro",
   isa    => ArrayRef->of(Str)->plus_coercions(Split[qr/\s/]),
   coerce => 1,
);

Join[a] — join an array of strings with a delimiter.

use Types::Standard qw( Str Join );

my $FileLines = Str->plus_coercions(Join["\n"]);

has file_contents => (
   is     => "ro",
   isa    => $FileLines,
   coerce => 1,
);

✨ Constants ✨

Types::Standard::STRICTNUM — indicates whether Num is an alias for StrictNum. (It is usually an alias for LaxNum.) iykyk

🌈 Environment 🌈

PERL_TYPES_STANDARD_STRICTNUM — switches to more strict regexp-based number checking instead of using looks_like_number.
PERL_TYPE_TINY_XS — if set to false, can be used to suppress the loading of XS implementations of some type constraints.
PERL_ONLY — if PERL_TYPE_TINY_XS does not exist, can be set to true to suppress XS usage similarly. (Several other CPAN distributions also pay attention to this environment variable.) the more you know 💫

💀 BUGS 💀

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

not me asking you to file issues 💅

🫶 SEE ALSO 🫶

The Type::Tiny homepage: https://typetiny.toby.ink/.
Type::Tiny::Manual.
Type::Tiny, Type::Library, Type::Utils, Type::Coercion.
Moose::Util::TypeConstraints, Mouse::Util::TypeConstraints, MooseX::Types::Structured.
Types::XSD provides some type constraints based on XML Schema's data types; this includes constraints for ISO8601-formatted datetimes, integer ranges (e.g. PositiveInteger[maxInclusive=>10] and so on.
Types::Encodings provides Bytes and Chars type constraints that were formerly found in Types::Standard.
Types::Common::Numeric and Types::Common::String provide replacements for MooseX::Types::Common.

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

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

and that's the whole page bestie, we did it 🫶 this was Types::Standard(3), from perl v5.42.0, dated 2026-01-17. go forth and type-check responsibly ✨💖

📦 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