NAME

Types::Standard - bundled set of built-in types for Type::Tiny

DESCRIPTION

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

Moose-like

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

Any

Item

Bool

Maybe[`a]

Undef

Defined

Value

Str

Num

Int

ClassName

RoleName

Ref[`a]

ScalarRef[`a]

ArrayRef[`a]

HashRef[`a]

CodeRef

RegexpRef

GlobRef

FileHandle

Object

Unlike Moose, Ref is a parameterized type, allowing Scalar::Util::reftype checks, a la

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

Structured

OK, so I stole some ideas from MooseX::Types::Structured.

Map[`a]

Tuple[`a]

Dict[`a]

Optional[`a]

This module also exports a slurpy function.

More

There are a few other types exported by this function:

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["+", "-"]

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 !!

If you need to check that something is specifically a reference to a tied hash, use an intersection:

   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

StrMatch[`a]

A string that matches a regular exception:

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

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

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

Bytes

Strings where utf8::is_utf8() is false.

Chars

Strings where either utf8::is_utf8() is true, or each byte is below 0x7F.

OptList

An arrayref of arrayrefs in the style of Data::OptList output.

Coercions

None of the types in this type library have any coercions by default. However some standalone coercions may be exported. These can be combined with type constraints using the + operator.

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 + MkOpt,
      coerce => 1,
   );

Encode[`a]

Coercion to encode a character string to a byte string using Encode::encode(). This is a parameterized type coercion, which expects a character set:

   use Types::Standard qw( Bytes Encode );
   
   has filename => (
      is     => "ro",
      isa    => Bytes + Encode["utf-8"],
      coerce => 1,
   );

Decode[`a]

Coercion to decode a byte string to a character string using Encode::decode(). This is a parameterized type coercion, which expects a character set.

Split[`a]

Split a string on a regexp.

   use Types::Standard qw( ArrayRef Str Split );
   
   has name => (
      is     => "ro",
      isa    => (ArrayRef[Str]) + (Split[qr/\s/]),
      coerce => 1,
   );

Join[`a]

Join an array of strings with a delimiter.

   use Types::Standard qw( Bytes Join );
   
   my $FileLines = Bytes + Join["\n"];
   
   has file_contents => (
      is     => "ro",
      isa    => $FileLines,
      coerce => 1,
   );

BUGS

Please report any bugs to http://rt.cpan.org/Dist/Display.html?Queue=Type-Tiny.

SEE ALSO

Type::Tiny::Manual.

Type::Tiny, Type::Library, Type::Utils, Type::Coercion.

Moose::Util::TypeConstraints, Mouse::Util::TypeConstraints, MooseX::Types::Structured.

AUTHOR

Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE

This software is copyright (c) 2013 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

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.

cpanm Type::Tiny

perl -MCPAN -e shell
install Type::Tiny