Type::Tiny is probably best known as a way of having Moose-like type constraints in Moo, but it can be used for so much more. This is the third in a series of posts showing other things you can use Type::Tiny for. This article along with part 1, part 2, and part 3 can be found on my blog and in the Cool Uses for Perl section of PerlMonks.

Even if you read the documentation of Types::Standard pretty thoroughly, you'd probably miss that you can do things like this:

   use Types::Standard qw(is_ArrayRef is_HashRef);
   
   if (is_ArrayRef($var)) {
      ...;
   }
   elsif (is_HashRef($var)) {
      ...;
   }

It is documented that Types::Standard exports functions called ArrayRef and HashRef, which are constant-like functions returning Moose/Moo-compatible type constraint objects, but where did these is_ArrayRef and is_HashRef functions come from?

Well, their existence is documented in Type::Library, the type library base class used by Types::Standard. Any type library built with it will offer is_* variants of type constraints. These functions check their argument and return a boolean indicating whether it passes the type constraint.

The object-oriented way of writing these checks is like this:

   use Types::Standard qw(ArrayRef HashRef);
   
   if (ArrayRef->check($var)) {
      ...;
   }
   elsif (HashRef->check($var)) {
      ...;
   }

Though the object-oriented way is a little slower because it will result in at least three sub calls (including a method call).

The is_* functions should be pretty darn fast, especially if Type::Tiny::XS is installed. Ref::Util::XS is faster, and Params::Util is sometimes faster, but using Type::Library-based type libraries (such as Types::Standard, Types::Common::Numeric, Types::Common::String, Types::Path::Tiny, Types::XSD, etc) will give you a richer selection of types that you can check.

Assertions

A common use for type checking functions is to do something like:

   is_ArrayRef($var) or die(...);

Type::Library-based type libraries offer a shortcut for this:

   assert_ArrayRef($var);

The return value of the assert_* functions (if they don't die) is the parameter you passed to them, which makes it convenient to do things like:

   use Types::Standard qw(assert_Object assert_ArrayRef);
   
   sub process_data {
      my $self  = assert_Object( $_[0] );
      my $data  = assert_ArrayRef( $_[1] );
      ...;
   }

The object-oriented equivalent of assert_Object($thing) is Object->assert_return($thing). Due to overloading Object->($thing) will also work.

Coercions

If a type constraint has coercions (like Path from Types::Path::Tiny), there's also a to_* function:

   use Types::Path::Tiny qw( to_Path );
   
   my $path = to_Path($thing);

Note that if a coercion fails, there is no exception thrown, and the original value is passed through unaltered. If you want to make sure coercion succeeded:

   use Types::Path::Tiny qw( assert_Path to_Path );
   
   my $path = assert_Path( to_Path($thing) );

The object-oriented equivalent of to_Path($thing) is Path->coerce($thing). The object-oriented equivalent of assert_Path(to_Path($thing)) is Path->assert_coerce($thing).

Parameterized Types

It would be pretty cool if you could do:

   if (is_ArrayRef[Int]($var)) {
      ...;
   }

But that wouldn't be syntactically valid Perl.

You can do this though:

   use Types::Standard qw(ArrayRef Int);
   
   BEGIN {
      my $type = ArrayRef->of(Int);
      *is_ArrayRef_of_Int     = $type->compiled_check;
      *assert_ArrayRef_of_Int = \&{ $type };
      *to_ArrayRef_of_Int     = sub { $type->coerce(@_) };
   }
   
   if (is_ArrayRef_of_Int($var)) {
      ...;
   }

Exporting Tricks

To export just Object:

   use Types::Standard qw(Object);

To export just is_Object:

   use Types::Standard qw(is_Object);

To export Object and is_Object:

   use Types::Standard qw(Object is_Object);

To export Object and all related functions (is_Object, assert_Object, and to_Object):

   use Types::Standard qw(+Object);

To export Object, ArrayRef, and all the other types:

   use Types::Standard qw(:types);

To export Object, ArrayRef, all the other types, and the related is_* functions:

   use Types::Standard qw(:types :is);

To export Object, ArrayRef, all the other types, and the related is_*, assert_*, and to_* functions:

   use Types::Standard qw(:types :is :assert :to);