Type::Tiny::Manual::UsingWithMoose - phpMan

NAME
    Type::Tiny::Manual::UsingWithMoose - how to use Type::Tiny with Moose

MANUAL
    First read Type::Tiny::Manual::Moo, Type::Tiny::Manual::Moo2, and
    Type::Tiny::Manual::Moo3. Everything in those parts of the manual should
    work exactly the same in Moose.

    This part of the manual will focus on Moose-specifics.

  Why Use Type::Tiny At All?
    Moose does have a built-in type constraint system which is fairly
    convenient to use, but there are several reasons you should consider
    using Type::Tiny instead.

    *   Type::Tiny type constraints will usually be faster than Moose
        built-ins. Even without Type::Tiny::XS installed, Type::Tiny usually
        produces more efficient inline code than Moose. Coercions will
        usually be a lot faster.

    *   Type::Tiny provides helpful methods like "where" and
        "plus_coercions" that allow type constraints and coercions to be
        easily tweaked on a per-attribute basis.

        Something like this is much harder to do with plain Moose types:

          has name => (
            is      => "ro",
            isa     => Str->plus_coercions(
              ArrayRef[Str], sub { join " ", @$_ },
            ),
            coerce  => 1,
          );

        Moose tends to encourage defining coercions globally, so if you
        wanted one Str attribute to be able to coerce from ArrayRef[Str],
        then *all* Str attributes would coerce from ArrayRef[Str], and
        they'd all do that coercion in the same way. (Even if it might make
        sense to join by a space in some places, a comma in others, and a
        line break in others!)

    *   Type::Tiny provides automatic deep coercions, so if type Xyz has a
        coercion, the following should "just work":

          isa xyzlist => ( is => 'ro', isa => ArrayRef[Xyz], coerce => 1 );

    *   Type::Tiny offers a wider selection of built-in types.

    *   By using Type::Tiny, you can use the same type constraints and
        coercions for attributes and method parameters, in Moose and
        non-Moose code.

  Type::Utils
    If you've used Moose::Util::TypeConstraints, you may be accustomed to
    using a DSL for declaring type constraints:

      use Moose::Util::TypeConstraints;

      subtype 'Natural',
        as 'Int',
        where { $_ > 0 };

    There's a module called Type::Utils that provides a very similar DSL for
    declaring types in Type::Library-based type libraries.

      package My::Types {
        use Type::Library -base;
        use Type::Utils;
        use Types::Standard qw( Int );

        declare 'Natural',
          as Int,
          where { $_ > 0 };
      }

    Personally I prefer the more object-oriented way to declare types
    though.

    Since Type::Library 1.012, a shortcut has been available for importing
    Type::Library and Type::Utils at the same time:

      package MyType {
        use Type::Library -base, -utils;

        ...;
      }

    In Moose you might also declare types like this within classes and roles
    too. Unlike Moose, Type::Tiny doesn't keep types in a single global flat
    namespace, so this doesn't work quite the same with Type::Utils. It
    still creates the type, but it doesn't store it in any type library; the
    type is returned.

      package My::Class {
        use Moose;
        use Type::Utils;
        use Types::Standard qw( Int );

        my $Natural =          # store type in a variable
          declare 'Natural',
          as Int,
          where { $_ > 0 };

        has number => ( is => 'ro', isa => $Natural );
      }

    But really, isn't the object-oriented way cleaner?

      package My::Class {
        use Moose;
        use Types::Standard qw( Int );

        has number => (
          is   => 'ro',
          isa  => Int->where('$_ > 0'),
        );
      }

  Type::Tiny and MooseX::Types
    Types::Standard should be a drop-in replacement for MooseX::Types. And
    Types::Common::Numeric and Types::Common::String should easily replace
    MooseX::Types::Common::Numeric and MooseX::Types::Common::String.

    That said, if you do with to use a mixture of Type::Tiny and
    MooseX::Types, they should fit together pretty seamlessly.

      use Types::Standard qw( ArrayRef );
      use MooseX::Types::Common::Numeric qw( PositiveInt );

      # this should just work
      my $list_of_nums = ArrayRef[PositiveInt];

      # and this
      my $list_or_num = ArrayRef | PositiveInt;

  "-moose" Import Parameter
    If you have read this far in the manual, you will know that this is the
    usual way to import type constraints:

      use Types::Standard qw( Int );

    And the "Int" which is imported is a function that takes no arguments
    and returns the Int type constraint, which is a blessed object in the
    Type::Tiny class.

    Type::Tiny mocks the Moose::Meta::TypeConstraint API so well that most
    Moose and MooseX code will not be able to tell the difference.

    But what if you need a real Moose::Meta::TypeConstraint object?

      use Types::Standard -moose, qw( Int );

    Now the "Int" function imported will return a genuine native Moose type
    constraint.

    This flag is mostly a throwback from when Type::Tiny native objects
    *didn't* directly work in Moose. In 99.9% of cases, there is no reason
    to use it and plenty of reasons not to. (Moose native type constraints
    don't offer helpful methods like "plus_coercions" and "where".)

  "moose_type" Method
    Another quick way to get a native Moose type constraint object from a
    Type::Tiny object is to call the "moose_type" method:

      use Types::Standard qw( Int );

      my $tiny_type   = Int;
      my $moose_type  = $tiny_type->moose_type;

    Internally, this is what the "-moose" flag makes imported functions do.

NEXT STEPS
    Here's your next step:

    *   Type::Tiny::Manual::UsingWithMouse

        How to use Type::Tiny with Mouse, including the advantages of
        Type::Tiny over built-in type constraints, and Mouse-specific
        features.

AUTHOR
    Toby Inkster <tobyink AT cpan.org>.

COPYRIGHT AND LICENCE
    This software is copyright (c) 2013-2014, 2017-2021 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.