Type::Tiny::Class - type constraints based on the "isa" method

       Toby Inkster <tobyink@cpan.org>.

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

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

       Type constraints of the general form "{ $_->isa("Some::Class") }".

       This package inherits from Type::Tiny; see that for most documentation.  Major differences are listed
       below:

   Constructor
       "new"
           When the constructor is called on an instance of Type::Tiny::Class, it passes the call through to the
           constructor of the class for the constraint.  So for example:

              my $type = Type::Tiny::Class->new(class => "Foo::Bar");
              my $obj  = $type->new(hello => "World");
              say ref($obj);   # prints "Foo::Bar"

           This  little  bit of DWIM was borrowed from MooseX::Types::TypeDecorator, but Type::Tiny doesn't take
           the idea quite as far.

   Attributes
       "class"
           The class for the constraint.

       "constraint"
           Unlike Type::Tiny, you cannot pass a constraint coderef to the  constructor.   Instead  rely  on  the
           default.

       "inlined"
           Unlike  Type::Tiny,  you  cannot  pass  an  inlining coderef to the constructor.  Instead rely on the
           default.

       "parent"
           Parent is automatically calculated, and cannot be passed to the constructor.

   Methods
       "plus_constructors($source, $method_name)"
           Much like "plus_coercions" but adds  coercions  that  go  via  a  constructor.   (In  fact,  this  is
           implemented as a wrapper for "plus_coercions".)

           Example:

              package MyApp::Minion;

              use Moose; extends "MyApp::Person";

              use Types::Standard qw( HashRef Str );
              use Type::Utils qw( class_type );

              my $Person = class_type({ class => "MyApp::Person" });

              has boss => (
                 is     => "ro",
                 isa    => $Person->plus_constructors(
                    HashRef,     "new",
                    Str,         "_new_from_name",
                 ),
                 coerce => 1,
              );

              package main;

              MyApp::Minion->new(
                 ...,
                 boss => "Bob",  ## via MyApp::Person->_new_from_name
              );

              MyApp::Minion->new(
                 ...,
                 boss => { name => "Bob" },  ## via MyApp::Person->new
              );

           Because  coercing  "HashRef" via constructor is a common desire, if you call "plus_constructors" with
           no arguments at all, this is the default.

              $classtype->plus_constructors(HashRef, "new")
              $classtype->plus_constructors()  ## identical to above

           This is handy for Moose/Mouse/Moo-based classes.

       stringifies_to($constraint)
           See Type::Tiny::ConstrainedObject.

       numifies_to($constraint)
           See Type::Tiny::ConstrainedObject.

       "with_attribute_values($attr1 => $constraint1, ...)"
           See Type::Tiny::ConstrainedObject.

   Exports
       Type::Tiny::Class can be used as an exporter.

         use Type::Tiny::Class 'HTTP::Tiny';

       This will export the following functions into your namespace:

       "HTTPTiny"
       is_HTTPTiny( $value )
       assert_HTTPTiny( $value )
       to_HTTPTiny( $value )

       You will also be able to use "HTTPTiny->new(...)" as a shortcut for "HTTP::Tiny->new(...)".

       Multiple types can be exported at once:

         use Type::Tiny::Class qw( HTTP::Tiny LWP::UserAgent );

       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.

perl v5.40.1                                       2025-05-06                             Type::Tiny::Class(3pm)

       Type::Tiny::Class - type constraints based on the "isa" method

       Type::Tiny::Manual.

       Type::Tiny.

       Moose::Meta::TypeConstraint::Class.

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

       Using via Types::Standard:

         package Local::Horse {
           use Moo;
           use Types::Standard qw( Str InstanceOf );

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

           has owner => (
             is       => 'ro',
             isa      => InstanceOf[ 'Local::Person' ],
             default  => sub { Local::Person->new },
           );
         }

       Using Type::Tiny::Class's export feature:

         package Local::Horse {
           use Moo;
           use Types::Standard qw( Str );
           use Type::Tiny::Class 'Local::Person';

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

           has owner => (
             is       => 'ro',
             isa      => LocalPerson,
             default  => sub { LocalPerson->new },
           );
         }

       Using Type::Tiny::Class's object-oriented interface:

         package Local::Horse {
           use Moo;
           use Types::Standard qw( Str );
           use Type::Tiny::Class;

           my $Person = Type::Tiny::Class->new( class => 'Local::Person' );

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

           has owner => (
             is       => 'ro',
             isa      => $Person,
             default  => sub { $Person->new },
           );
         }

       Using Type::Utils's functional interface:

         package Local::Horse {
           use Moo;
           use Types::Standard qw( Str );
           use Type::Utils;

           my $Person = class_type 'Local::Person';

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

           has owner => (
             is       => 'ro',
             isa      => $Person,
             default  => sub { $Person->new },
           );
         }