1Type::Tiny(3)         User Contributed Perl Documentation        Type::Tiny(3)
2
3
4

NAME

6       Type::Tiny - tiny, yet Moo(se)-compatible type constraint
7

SYNOPSIS

9        use v5.12;
10        use strict;
11        use warnings;
12
13        package Horse {
14          use Moo;
15          use Types::Standard qw( Str Int Enum ArrayRef Object );
16          use Type::Params qw( compile );
17          use namespace::autoclean;
18
19          has name => (
20            is       => 'ro',
21            isa      => Str,
22            required => 1,
23          );
24          has gender => (
25            is       => 'ro',
26            isa      => Enum[qw( f m )],
27          );
28          has age => (
29            is       => 'rw',
30            isa      => Int->where( '$_ >= 0' ),
31          );
32          has children => (
33            is       => 'ro',
34            isa      => ArrayRef[Object],
35            default  => sub { return [] },
36          );
37
38          sub add_child {
39            state $check = compile( Object, Object );  # method signature
40
41            my ($self, $child) = $check->(@_);         # unpack @_
42            push @{ $self->children }, $child;
43
44            return $self;
45          }
46        }
47
48        package main;
49
50        my $boldruler = Horse->new(
51          name    => "Bold Ruler",
52          gender  => 'm',
53          age     => 16,
54        );
55
56        my $secretariat = Horse->new(
57          name    => "Secretariat",
58          gender  => 'm',
59          age     => 0,
60        );
61
62        $boldruler->add_child( $secretariat );
63

STATUS

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

DESCRIPTION

68       This documents the internals of the Type::Tiny class.
69       Type::Tiny::Manual is a better starting place if you're new.
70
71       Type::Tiny is a small class for creating Moose-like type constraint
72       objects which are compatible with Moo, Moose and Mouse.
73
74          use Scalar::Util qw(looks_like_number);
75          use Type::Tiny;
76
77          my $NUM = "Type::Tiny"->new(
78             name       => "Number",
79             constraint => sub { looks_like_number($_) },
80             message    => sub { "$_ ain't a number" },
81          );
82
83          package Ermintrude {
84             use Moo;
85             has favourite_number => (is => "ro", isa => $NUM);
86          }
87
88          package Bullwinkle {
89             use Moose;
90             has favourite_number => (is => "ro", isa => $NUM);
91          }
92
93          package Maisy {
94             use Mouse;
95             has favourite_number => (is => "ro", isa => $NUM);
96          }
97
98       Maybe now we won't need to have separate MooseX, MouseX and MooX
99       versions of everything? We can but hope...
100
101   Constructor
102       "new(%attributes)"
103           Moose-style constructor function.
104
105   Attributes
106       Attributes are named values that may be passed to the constructor. For
107       each attribute, there is a corresponding reader method. For example:
108
109          my $type = Type::Tiny->new( name => "Foo" );
110          print $type->name, "\n";   # says "Foo"
111
112       Important attributes
113
114       These are the attributes you are likely to be most interested in
115       providing when creating your own type constraints, and most interested
116       in reading when dealing with type constraint objects.
117
118       "constraint"
119           Coderef to validate a value ($_) against the type constraint.  The
120           coderef will not be called unless the value is known to pass any
121           parent type constraint (see "parent" below).
122
123           Alternatively, a string of Perl code checking $_ can be passed as a
124           parameter to the constructor, and will be converted to a coderef.
125
126           Defaults to "sub { 1 }" - i.e. a coderef that passes all values.
127
128       "parent"
129           Optional attribute; parent type constraint. For example, an
130           "Integer" type constraint might have a parent "Number".
131
132           If provided, must be a Type::Tiny object.
133
134       "inlined"
135           A coderef which returns a string of Perl code suitable for inlining
136           this type. Optional.
137
138           (The coderef will be called in list context and can actually return
139           a list of strings which will be joined with "&&". If the first item
140           on the list is undef, it will be substituted with the type's
141           parent's inline check.)
142
143           If "constraint" (above) is a coderef generated via Sub::Quote, then
144           Type::Tiny may be able to automatically generate "inlined" for you.
145           If "constraint" (above) is a string, it will be able to.
146
147       "name"
148           The name of the type constraint. These need to conform to certain
149           naming rules (they must begin with an uppercase letter and continue
150           using only letters, digits 0-9 and underscores).
151
152           Optional; if not supplied will be an anonymous type constraint.
153
154       "display_name"
155           A name to display for the type constraint when stringified. These
156           don't have to conform to any naming rules. Optional; a default name
157           will be calculated from the "name".
158
159       "library"
160           The package name of the type library this type is associated with.
161           Optional. Informational only: setting this attribute does not
162           install the type into the package.
163
164       "deprecated"
165           Optional boolean indicating whether a type constraint is
166           deprecated.  Type::Library will issue a warning if you attempt to
167           import a deprecated type constraint, but otherwise the type will
168           continue to function as normal.  There will not be deprecation
169           warnings every time you validate a value, for instance. If omitted,
170           defaults to the parent's deprecation status (or false if there's no
171           parent).
172
173       "message"
174           Coderef that returns an error message when $_ does not validate
175           against the type constraint. Optional (there's a vaguely sensible
176           default.)
177
178       "coercion"
179           A Type::Coercion object associated with this type.
180
181           Generally speaking this attribute should not be passed to the
182           constructor; you should rely on the default lazily-built coercion
183           object.
184
185           You may pass "coercion => 1" to the constructor to inherit
186           coercions from the constraint's parent. (This requires the parent
187           constraint to have a coercion.)
188
189       "sorter"
190           A coderef which can be passed two values conforming to this type
191           constraint and returns -1, 0, or 1 to put them in order.
192           Alternatively an arrayref containing a pair of coderefs — a sorter
193           and a pre-processor for the Schwarzian transform. Optional.
194
195           The idea is to allow for:
196
197             @sorted = Int->sort( 2, 1, 11 );    # => 1, 2, 11
198             @sorted = Str->sort( 2, 1, 11 );    # => 1, 11, 2
199
200       "my_methods"
201           Experimental hashref of additional methods that can be called on
202           the type constraint object.
203
204       Attributes related to parameterizable and parameterized types
205
206       The following additional attributes are used for parameterizable (e.g.
207       "ArrayRef") and parameterized (e.g. "ArrayRef[Int]") type constraints.
208       Unlike Moose, these aren't handled by separate subclasses.
209
210       "constraint_generator"
211           Coderef that is called when a type constraint is parameterized.
212           When called, it is passed the list of parameters, though any
213           parameter which looks like a foreign type constraint (Moose type
214           constraints, Mouse type constraints, etc, and coderefs(!!!)) is
215           first coerced to a native Type::Tiny object.
216
217           Note that for compatibility with the Moose API, the base type is
218           not passed to the constraint generator, but can be found in the
219           package variable $Type::Tiny::parameterize_type. The first
220           parameter is also available as $_.
221
222           Types can be parameterized with an empty parameter list. For
223           example, in Types::Standard, "Tuple" is just an alias for
224           "ArrayRef" but "Tuple[]" will only allow zero-length arrayrefs to
225           pass the constraint.  If you wish "YourType" and "YourType[]" to
226           mean the same thing, then do:
227
228            return $Type::Tiny::parameterize_type unless @_;
229
230           The constraint generator should generate and return a new
231           constraint coderef based on the parameters. Alternatively, the
232           constraint generator can return a fully-formed Type::Tiny object,
233           in which case the "name_generator", "inline_generator", and
234           "coercion_generator" attributes documented below are ignored.
235
236           Optional; providing a generator makes this type into a
237           parameterizable type constraint. If there is no generator,
238           attempting to parameterize the type constraint will throw an
239           exception.
240
241       "name_generator"
242           A coderef which generates a new display_name based on parameters.
243           Called with the same parameters and package variables as the
244           "constraint_generator".  Expected to return a string.
245
246           Optional; the default is reasonable.
247
248       "inline_generator"
249           A coderef which generates a new inlining coderef based on
250           parameters. Called with the same parameters and package variables
251           as the "constraint_generator".  Expected to return a coderef.
252
253           Optional.
254
255       "coercion_generator"
256           A coderef which generates a new Type::Coercion object based on
257           parameters.  Called with the same parameters and package variables
258           as the "constraint_generator". Expected to return a blessed object.
259
260           Optional.
261
262       "deep_explanation"
263           This API is not finalized. Coderef used by
264           Error::TypeTiny::Assertion to peek inside parameterized types and
265           figure out why a value doesn't pass the constraint.
266
267       "parameters"
268           In parameterized types, returns an arrayref of the parameters.
269
270       Lazy generated attributes
271
272       The following attributes should not be usually passed to the
273       constructor; unless you're doing something especially unusual, you
274       should rely on the default lazily-built return values.
275
276       "compiled_check"
277           Coderef to validate a value ($_[0]) against the type constraint.
278           This coderef is expected to also handle all validation for the
279           parent type constraints.
280
281       "complementary_type"
282           A complementary type for this type. For example, the complementary
283           type for an integer type would be all things that are not integers,
284           including floating point numbers, but also alphabetic strings,
285           arrayrefs, filehandles, etc.
286
287       "moose_type", "mouse_type"
288           Objects equivalent to this type constraint, but as a
289           Moose::Meta::TypeConstraint or Mouse::Meta::TypeConstraint.
290
291           It should rarely be necessary to obtain a
292           Moose::Meta::TypeConstraint object from Type::Tiny because the
293           Type::Tiny object itself should be usable pretty much anywhere a
294           Moose::Meta::TypeConstraint is expected.
295
296   Methods
297       Predicate methods
298
299       These methods return booleans indicating information about the type
300       constraint. They are each tightly associated with a particular
301       attribute.  (See "Attributes".)
302
303       "has_parent", "has_library", "has_inlined", "has_constraint_generator",
304       "has_inline_generator", "has_coercion_generator", "has_parameters",
305       "has_message", "has_deep_explanation", "has_sorter"
306           Simple Moose-style predicate methods indicating the presence or
307           absence of an attribute.
308
309       "has_coercion"
310           Predicate method with a little extra DWIM. Returns false if the
311           coercion is a no-op.
312
313       "is_anon"
314           Returns true iff the type constraint does not have a "name".
315
316       "is_parameterized", "is_parameterizable"
317           Indicates whether a type has been parameterized (e.g.
318           "ArrayRef[Int]") or could potentially be (e.g. "ArrayRef").
319
320       "has_parameterized_from"
321           Useless alias for "is_parameterized".
322
323       Validation and coercion
324
325       The following methods are used for coercing and validating values
326       against a type constraint:
327
328       "check($value)"
329           Returns true iff the value passes the type constraint.
330
331       "validate($value)"
332           Returns the error message for the value; returns an explicit undef
333           if the value passes the type constraint.
334
335       "assert_valid($value)"
336           Like "check($value)" but dies if the value does not pass the type
337           constraint.
338
339           Yes, that's three very similar methods. Blame
340           Moose::Meta::TypeConstraint whose API I'm attempting to emulate.
341           :-)
342
343       "assert_return($value)"
344           Like "assert_valid($value)" but returns the value if it passes the
345           type constraint.
346
347           This seems a more useful behaviour than "assert_valid($value)". I
348           would have just changed "assert_valid($value)" to do this, except
349           that there are edge cases where it could break Moose compatibility.
350
351       "get_message($value)"
352           Returns the error message for the value; even if the value passes
353           the type constraint.
354
355       "validate_explain($value, $varname)"
356           Like "validate" but instead of a string error message, returns an
357           arrayref of strings explaining the reasoning why the value does not
358           meet the type constraint, examining parent types, etc.
359
360           The $varname is an optional string like '$foo' indicating the name
361           of the variable being checked.
362
363       "coerce($value)"
364           Attempt to coerce $value to this type.
365
366       "assert_coerce($value)"
367           Attempt to coerce $value to this type. Throws an exception if this
368           is not possible.
369
370       Child type constraint creation and parameterization
371
372       These methods generate new type constraint objects that inherit from
373       the constraint they are called upon:
374
375       "create_child_type(%attributes)"
376           Construct a new Type::Tiny object with this object as its parent.
377
378       "where($coderef)"
379           Shortcut for creating an anonymous child type constraint. Use it
380           like "HashRef->where(sub { exists($_->{name}) })". That said, you
381           can get a similar result using overloaded "&":
382
383              HashRef & sub { exists($_->{name}) }
384
385           Like the "constraint" attribute, this will accept a string of Perl
386           code:
387
388              HashRef->where('exists($_->{name})')
389
390       "child_type_class"
391           The class that create_child_type will construct by default.
392
393       "parameterize(@parameters)"
394           Creates a new parameterized type; throws an exception if called on
395           a non-parameterizable type.
396
397       "of(@parameters)"
398           A cute alias for "parameterize". Use it like "ArrayRef->of(Int)".
399
400       "plus_coercions($type1, $code1, ...)"
401           Shorthand for creating a new child type constraint with the same
402           coercions as this one, but then adding some extra coercions (at a
403           higher priority than the existing ones).
404
405       "plus_fallback_coercions($type1, $code1, ...)"
406           Like "plus_coercions", but added at a lower priority.
407
408       "minus_coercions($type1, ...)"
409           Shorthand for creating a new child type constraint with fewer type
410           coercions.
411
412       "no_coercions"
413           Shorthand for creating a new child type constraint with no
414           coercions at all.
415
416       Type relationship introspection methods
417
418       These methods allow you to determine a type constraint's relationship
419       to other type constraints in an organised hierarchy:
420
421       "equals($other)", "is_subtype_of($other)", "is_supertype_of($other)",
422       "is_a_type_of($other)"
423           Compare two types. See Moose::Meta::TypeConstraint for what these
424           all mean.  (OK, Moose doesn't define "is_supertype_of", but you get
425           the idea, right?)
426
427           Note that these have a slightly DWIM side to them. If you create
428           two Type::Tiny::Class objects which test the same class, they're
429           considered equal. And:
430
431              my $subtype_of_Num = Types::Standard::Num->create_child_type;
432              my $subtype_of_Int = Types::Standard::Int->create_child_type;
433              $subtype_of_Int->is_subtype_of( $subtype_of_Num );  # true
434
435       "strictly_equals($other)", "is_strictly_subtype_of($other)",
436       "is_strictly_supertype_of($other)", "is_strictly_a_type_of($other)"
437           Stricter versions of the type comparison functions. These only care
438           about explicit inheritance via "parent".
439
440              my $subtype_of_Num = Types::Standard::Num->create_child_type;
441              my $subtype_of_Int = Types::Standard::Int->create_child_type;
442              $subtype_of_Int->is_strictly_subtype_of( $subtype_of_Num );  # false
443
444       "parents"
445           Returns a list of all this type constraint's ancestor constraints.
446           For example, if called on the "Str" type constraint would return
447           the list "(Value, Defined, Item, Any)".
448
449           Due to a historical misunderstanding, this differs from the Moose
450           implementation of the "parents" method. In Moose, "parents" only
451           returns the immediate parent type constraints, and because type
452           constraints only have one immediate parent, this is effectively an
453           alias for "parent". The extension module
454           MooseX::Meta::TypeConstraint::Intersection is the only place where
455           multiple type constraints are returned; and they are returned as an
456           arrayref in violation of the base class' documentation. I'm keeping
457           my behaviour as it seems more useful.
458
459       "find_parent($coderef)"
460           Loops through the parent type constraints including the invocant
461           itself and returns the nearest ancestor type constraint where the
462           coderef evaluates to true. Within the coderef the ancestor
463           currently being checked is $_. Returns undef if there is no match.
464
465           In list context also returns the number of type constraints which
466           had been looped through before the matching constraint was found.
467
468       "find_constraining_type"
469           Finds the nearest ancestor type constraint (including the type
470           itself) which has a "constraint" coderef.
471
472           Equivalent to:
473
474              $type->find_parent(sub { not $_->_is_null_constraint })
475
476       "coercibles"
477           Return a type constraint which is the union of type constraints
478           that can be coerced to this one (including this one). If this type
479           constraint has no coercions, returns itself.
480
481       "type_parameter"
482           In parameterized type constraints, returns the first item on the
483           list of parameters; otherwise returns undef. For example:
484
485              ( ArrayRef[Int] )->type_parameter;    # returns Int
486              ( ArrayRef[Int] )->parent;            # returns ArrayRef
487
488           Note that parameterizable type constraints can perfectly
489           legitimately take multiple parameters (several of the
490           parameterizable type constraints in Types::Standard do). This
491           method only returns the first such parameter.  "Attributes related
492           to parameterizable and parameterized types" documents the
493           "parameters" attribute, which returns an arrayref of all the
494           parameters.
495
496       "parameterized_from"
497           Harder to spell alias for "parent" that only works for
498           parameterized types.
499
500       Hint for people subclassing Type::Tiny: Since version 1.006000, the
501       methods for determining subtype, supertype, and type equality should
502       not be overridden in subclasses of Type::Tiny. This is because of the
503       problem of diamond inheritance. If X and Y are both subclasses of
504       Type::Tiny, they both need to be consulted to figure out how type
505       constraints are related; not just one of them should be overriding
506       these methods. See the source code for Type::Tiny::Enum for an example
507       of how subclasses can give hints about type relationships to
508       Type::Tiny.  Summary: push a coderef onto @Type::Tiny::CMP. This
509       coderef will be passed two type constraints. It should then return one
510       of the constants Type::Tiny::CMP_SUBTYPE (first type is a subtype of
511       second type), Type::Tiny::CMP_SUPERTYPE (second type is a subtype of
512       first type), Type::Tiny::CMP_EQUAL (the two types are exactly the
513       same), Type::Tiny::CMP_EQUIVALENT (the two types are effectively the
514       same), or Type::Tiny::CMP_UNKNOWN (your coderef couldn't establish any
515       relationship).
516
517       Type relationship introspection function
518
519       "Type::Tiny::cmp($type1, $type2)"
520           The subtype/supertype relationship between types results in a
521           partial ordering of type constraints.
522
523           This function will return one of the constants:
524           Type::Tiny::CMP_SUBTYPE (first type is a subtype of second type),
525           Type::Tiny::CMP_SUPERTYPE (second type is a subtype of first type),
526           Type::Tiny::CMP_EQUAL (the two types are exactly the same),
527           Type::Tiny::CMP_EQUIVALENT (the two types are effectively the
528           same), or Type::Tiny::CMP_UNKNOWN (couldn't establish any
529           relationship).  In numeric contexts, these evaluate to -1, 1, 0, 0,
530           and 0, making it potentially usable with "sort" (though you may
531           need to silence warnings about treating the empty string as a
532           numeric value).
533
534       List processing methods
535
536       "grep(@list)"
537           Filters a list to return just the items that pass the type check.
538
539             @integers = Int->grep(@list);
540
541       "first(@list)"
542           Filters the list to return the first item on the list that passes
543           the type check, or undef if none do.
544
545             $first_lady = Woman->first(@people);
546
547       "map(@list)"
548           Coerces a list of items. Only works on types which have a coercion.
549
550             @truths = Bool->map(@list);
551
552       "sort(@list)"
553           Sorts a list of items according to the type's preferred sorting
554           mechanism, or if the type doesn't have a sorter coderef, uses the
555           parent type. If no ancestor type constraint has a sorter, throws an
556           exception. The "Str", "StrictNum", "LaxNum", and "Enum" type
557           constraints include sorters.
558
559             @sorted_numbers = Num->sort( Num->grep(@list) );
560
561       "rsort(@list)"
562           Like "sort" but backwards.
563
564       "any(@list)"
565           Returns true if any of the list match the type.
566
567             if ( Int->any(@numbers) ) {
568               say "there was at least one integer";
569             }
570
571       "all(@list)"
572           Returns true if all of the list match the type.
573
574             if ( Int->all(@numbers) ) {
575               say "they were all integers";
576             }
577
578       "assert_any(@list)"
579           Like "any" but instead of returning a boolean, returns the entire
580           original list if any item on it matches the type, and dies if none
581           does.
582
583       "assert_all(@list)"
584           Like "all" but instead of returning a boolean, returns the original
585           list if all items on it match the type, but dies as soon as it
586           finds one that does not.
587
588       Inlining methods
589
590       The following methods are used to generate strings of Perl code which
591       may be pasted into stringy "eval"uated subs to perform type checks:
592
593       "can_be_inlined"
594           Returns boolean indicating if this type can be inlined.
595
596       "inline_check($varname)"
597           Creates a type constraint check for a particular variable as a
598           string of Perl code. For example:
599
600              print( Types::Standard::Num->inline_check('$foo') );
601
602           prints the following output:
603
604              (!ref($foo) && Scalar::Util::looks_like_number($foo))
605
606           For Moose-compat, there is an alias "_inline_check" for this
607           method.
608
609       "inline_assert($varname)"
610           Much like "inline_check" but outputs a statement of the form:
611
612              ... or die ...;
613
614           Can also be called line "inline_assert($varname, $typevarname,
615           %extras)".  In this case, it will generate a string of code that
616           may include $typevarname which is supposed to be the name of a
617           variable holding the type itself. (This is kinda complicated, but
618           it allows a useful string to still be produced if the type is not
619           inlineable.) The %extras are additional options to be passed to
620           Error::TypeTiny::Assertion's constructor and must be key-value
621           pairs of strings only, no references or undefs.
622
623       Other methods
624
625       "qualified_name"
626           For non-anonymous type constraints that have a library, returns a
627           qualified "MyLib::MyType" sort of name. Otherwise, returns the same
628           as "name".
629
630       "isa($class)", "can($method)", "AUTOLOAD(@args)"
631           If Moose is loaded, then the combination of these methods is used
632           to mock a Moose::Meta::TypeConstraint.
633
634           If Mouse is loaded, then "isa" mocks Mouse::Meta::TypeConstraint.
635
636       "DOES($role)"
637           Overridden to advertise support for various roles.
638
639           See also Type::API::Constraint, etc.
640
641       "TIESCALAR", "TIEARRAY", "TIEHASH"
642           These are provided as hooks that wrap Type::Tie. (Type::Tie is
643           distributed separately, and can be used with non-Type::Tiny type
644           constraints too.) They allow the following to work:
645
646              use Types::Standard qw(Int);
647              tie my @list, Int;
648              push @list, 123, 456;   # ok
649              push @list, "Hello";    # dies
650
651       The following methods exist for Moose/Mouse compatibility, but do not
652       do anything useful.
653
654       "compile_type_constraint"
655       "hand_optimized_type_constraint"
656       "has_hand_optimized_type_constraint"
657       "inline_environment"
658       "meta"
659
660   Overloading
661       •   Stringification is overloaded to return the qualified name.
662
663       •   Boolification is overloaded to always return true.
664
665       •   Coderefification is overloaded to call "assert_return".
666
667       •   On Perl 5.10.1 and above, smart match is overloaded to call
668           "check".
669
670       •   The "==" operator is overloaded to call "equals".
671
672       •   The "<" and ">" operators are overloaded to call "is_subtype_of"
673           and "is_supertype_of".
674
675       •   The "~" operator is overloaded to call "complementary_type".
676
677       •   The "|" operator is overloaded to build a union of two type
678           constraints.  See Type::Tiny::Union.
679
680       •   The "&" operator is overloaded to build the intersection of two
681           type constraints. See Type::Tiny::Intersection.
682
683       Previous versions of Type::Tiny would overload the "+" operator to call
684       "plus_coercions" or "plus_fallback_coercions" as appropriate.  Support
685       for this was dropped after 0.040.
686
687   Constants
688       "Type::Tiny::SUPPORT_SMARTMATCH"
689           Indicates whether the smart match overload is supported on your
690           version of Perl.
691
692   Package Variables
693       $Type::Tiny::DD
694           This undef by default but may be set to a coderef that Type::Tiny
695           and related modules will use to dump data structures in things like
696           error messages.
697
698           Otherwise Type::Tiny uses it's own routine to dump data structures.
699           $DD may then be set to a number to limit the lengths of the dumps.
700           (Default limit is 72.)
701
702           This is a package variable (rather than get/set class methods) to
703           allow for easy localization.
704
705       $Type::Tiny::AvoidCallbacks
706           If this variable is set to true (you should usually do it in a
707           "local" scope), it acts as a hint for type constraints, when
708           generating inlined code, to avoid making any callbacks to variables
709           and functions defined outside the inlined code itself.
710
711           This should have the effect that "$type->inline_check('$foo')" will
712           return a string of code capable of checking the type on Perl
713           installations that don't have Type::Tiny installed. This is
714           intended to allow Type::Tiny to be used with things like Mite.
715
716           The variable works on the honour system. Types need to explicitly
717           check it and decide to generate different code based on its truth
718           value. The bundled types in Types::Standard,
719           Types::Common::Numeric, and Types::Common::String all do.
720           (StrMatch is sometimes unable to, and will issue a warning if it
721           needs to rely on callbacks when asked not to.)
722
723           Most normal users can ignore this.
724
725   Environment
726       "PERL_TYPE_TINY_XS"
727           Currently this has more effect on Types::Standard than Type::Tiny.
728           In future it may be used to trigger or suppress the loading XS
729           implementations of parts of Type::Tiny.
730

BUGS

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

SEE ALSO

736       The Type::Tiny homepage <https://typetiny.toby.ink/>.
737
738       Type::Tiny::Manual, Type::API.
739
740       Type::Library, Type::Utils, Types::Standard, Type::Coercion.
741
742       Type::Tiny::Class, Type::Tiny::Role, Type::Tiny::Duck,
743       Type::Tiny::Enum, Type::Tiny::Union, Type::Tiny::Intersection.
744
745       Moose::Meta::TypeConstraint, Mouse::Meta::TypeConstraint.
746
747       Type::Params.
748
749       Type::Tiny on GitHub <https://github.com/tobyink/p5-type-tiny>,
750       Type::Tiny on Travis-CI <https://travis-ci.com/tobyink/p5-type-tiny>,
751       Type::Tiny on AppVeyor
752       <https://ci.appveyor.com/project/tobyink/p5-type-tiny>, Type::Tiny on
753       Codecov <https://codecov.io/gh/tobyink/p5-type-tiny>, Type::Tiny on
754       Coveralls <https://coveralls.io/github/tobyink/p5-type-tiny>.
755

AUTHOR

757       Toby Inkster <tobyink@cpan.org>.
758

THANKS

760       Thanks to Matt S Trout for advice on Moo integration.
761
763       This software is copyright (c) 2013-2014, 2017-2021 by Toby Inkster.
764
765       This is free software; you can redistribute it and/or modify it under
766       the same terms as the Perl 5 programming language system itself.
767

DISCLAIMER OF WARRANTIES

769       THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
770       WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
771       MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
772
773
774
775perl v5.32.1                      2021-04-27                     Type::Tiny(3)
Impressum