Type::Tiny::Manual::UsingWithOther - phpMan

NAME
    Type::Tiny::Manual::UsingWithOther - using Type::Tiny with
    Class::InsideOut, Params::Check, and Object::Accessor.

MANUAL
    The antlers crew aren't the only object-oriented programming toolkits in
    Perl town. Although Type::Tiny might have been built with Moose, Mouse,
    and Moo in mind, it can be used with other toolkits.

    These toolkits are... well... hmm... okay... they exist.

    If you are starting a new project, there's very little reason not to use
    Class::Tiny, Moo, or Moose. So you're probably okay to skip this part of
    the fine manual and go straight to
    Type::Tiny::Manual::UsingWithTestMore.

  Class::InsideOut
    You want Class::InsideOut 1.13 or above, which has support for blessed
    and overloaded objects (including Type::Tiny type constraints) for the
    "get_hook" and "set_hook" options.

      package Person {
        use Class::InsideOut qw( public );
        use Types::Standard qw( Str Int );
        use Types::Common::Numeric qw( PositiveInt );
        use Type::Params qw( compile );

        # Type checks are really easy.
        # Just supply the type as a set hook.
        public name => my %_name, {
          set_hook => Str,
        };

        # Define a type that silently coerces negative values
        # to positive. It's silly, but it works as an example!
        my $Years = PositiveInt->plus_coercions(Int, q{ abs($_) });

        # Coercions are more annoying, but possible.
        public age => my %_age, {
          set_hook => sub { $_ = $Years->assert_coerce($_) },
        };

        # Parameter checking for methods is as expected.
        sub get_older {
          state $check = compile( $Years );
          my $self = shift;
          my ($years) = $check->(@_);
          $self->_set_age($self->age + $years);
        }
      }

  Params::Check and Object::Accessor
    The Params::Check "allow()" function, the "allow" option for the
    Params::Check "check()" function, and the input validation mechanism for
    Object::Accessor all work in the same way, which is basically a limited
    pure-Perl implementation of the smart match operator. While this doesn't
    directly support Type::Tiny constraints, it does support coderefs. You
    can use Type::Tiny's "compiled_check" method to obtain a suitable
    coderef.

    Param::Check example:

      my $tmpl = {
        name => { allow => Str->compiled_check },
        age  => { allow => Int->compiled_check },
      };
      check($tmpl, { name => "Bob", age => 32 })
        or die Params::Check::last_error();

    Object::Accessor example:

      my $obj = Object::Accessor->new;
      $obj->mk_accessors(
        { name => Str->compiled_check },
        { age  => Int->compiled_check },
      );

    *Caveat:* Object::Accessor doesn't die when a value fails to meet its
    type constraint; instead it outputs a warning to STDERR. This behaviour
    can be changed by setting "$Object::Accessor::FATAL = 1".

  Class::Struct
    This is proof-of-concept of how Type::Tiny can be used to constrain
    attributes for Class::Struct. It's probably not a good idea to use this
    in production as it slows down "UNIVERSAL::isa" globally.

      use Types::Standard -types;
      use Class::Struct;

      {
        my %MAP;
        my $orig_isa = \&UNIVERSAL::isa;
        *UNIVERSAL::isa = sub {
          return $MAP{$1}->check($_[0])
            if $_[1] =~ /^CLASSSTRUCT::TYPETINY::(.+)$/ && exists $MAP{$1};
          goto $orig;
        };
        my $orig_dn = \&Type::Tiny::display_name;
        *Type::Tiny::display_name = sub {
          if (caller(1) eq 'Class::Struct') {
            $MAP{$_[0]{uniq}} = $_[0];
            return "CLASSSTRUCT::TYPETINY::".$_[0]{uniq};
          }
          goto $orig_dn;
        };
      }

      struct Person => [ name => Str, age => Int ];

      my $bob = Person->new(
        name => "Bob",
        age  => 21,
      );

      $bob->name("Robert");   # okay
      $bob->name([]);         # dies

NEXT STEPS
    Here's your next step:

    *   Type::Tiny::Manual::UsingWithTestMore

        Type::Tiny for test suites.

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.