1Type::Tiny(3) User Contributed Perl Documentation Type::Tiny(3)
2
6 Type::Tiny - tiny, yet Moo(se)-compatible type constraint
7
9 use v5.12;
10 use strict;
11 use warnings;
12 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 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 sub add_child {
39 state $check = compile( Object, Object ); # method signature
40 my ($self, $child) = $check->(@_); # unpack @_
42 push @{ $self->children }, $child;
43 return $self;
45 }
46 }
47 package main;
49 my $boldruler = Horse->new(
51 name => "Bold Ruler",
52 gender => 'm',
53 age => 16,
54 );
55 my $secretariat = Horse->new(
57 name => "Secretariat",
58 gender => 'm',
59 age => 0,
60 );
61 $boldruler->add_child( $secretariat );
63
65 This module is covered by the Type-Tiny stability policy.
66
68 This documents the internals of the Type::Tiny class.
69 Type::Tiny::Manual is a better starting place if you're new.
70 Type::Tiny is a small class for creating Moose-like type constraint
72 objects which are compatible with Moo, Moose and Mouse.
73 use Scalar::Util qw(looks_like_number);
75 use Type::Tiny;
76 my $NUM = "Type::Tiny"->new(
78 name => "Number",
79 constraint => sub { looks_like_number($_) },
80 message => sub { "$_ ain't a number" },
81 );
82 package Ermintrude {
84 use Moo;
85 has favourite_number => (is => "ro", isa => $NUM);
86 }
87 package Bullwinkle {
89 use Moose;
90 has favourite_number => (is => "ro", isa => $NUM);
91 }
92 package Maisy {
94 use Mouse;
95 has favourite_number => (is => "ro", isa => $NUM);
96 }
97 Maybe now we won't need to have separate MooseX, MouseX and MooX
99 versions of everything? We can but hope...
100 Constructor
102 "new(%attributes)"
103 Moose-style constructor function.
104 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 my $type = Type::Tiny->new( name => "Foo" );
110 print $type->name, "\n"; # says "Foo"
111 Important attributes
113 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 "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 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 Defaults to "sub { 1 }" - i.e. a coderef that passes all values.
127 "parent"
129 Optional attribute; parent type constraint. For example, an
130 "Integer" type constraint might have a parent "Number".
131 If provided, must be a Type::Tiny object.
133 "inlined"
135 A coderef which returns a string of Perl code suitable for inlining
136 this type. Optional.
137 (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 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 "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 Optional; if not supplied will be an anonymous type constraint.
153 "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 "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 "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 "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 "coercion"
179 A Type::Coercion object associated with this type.
180 Generally speaking this attribute should not be passed to the
182 constructor; you should rely on the default lazily-built coercion
183 object.
184 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 "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 The idea is to allow for:
196 @sorted = Int->sort( 2, 1, 11 ); # => 1, 2, 11
198 @sorted = Str->sort( 2, 1, 11 ); # => 1, 11, 2
199 "my_methods"
201 Experimental hashref of additional methods that can be called on
202 the type constraint object.
203 Attributes related to parameterizable and parameterized types
205 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 "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 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 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 return $Type::Tiny::parameterize_type unless @_;
229 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 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 "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 Optional; the default is reasonable.
247 "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 Optional.
254 "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 Optional.
261 "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 "parameters"
268 In parameterized types, returns an arrayref of the parameters.
269 Lazy generated attributes
271 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 "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 "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 "moose_type", "mouse_type"
288 Objects equivalent to this type constraint, but as a
289 Moose::Meta::TypeConstraint or Mouse::Meta::TypeConstraint.
290 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 Methods
297 Predicate methods
298 These methods return booleans indicating information about the type
300 constraint. They are each tightly associated with a particular
301 attribute. (See "Attributes".)
302 "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 "has_coercion"
310 Predicate method with a little extra DWIM. Returns false if the
311 coercion is a no-op.
312 "is_anon"
314 Returns true iff the type constraint does not have a "name".
315 "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 "has_parameterized_from"
321 Useless alias for "is_parameterized".
322 Validation and coercion
324 The following methods are used for coercing and validating values
326 against a type constraint:
327 "check($value)"
329 Returns true iff the value passes the type constraint.
330 "validate($value)"
332 Returns the error message for the value; returns an explicit undef
333 if the value passes the type constraint.
334 "assert_valid($value)"
336 Like "check($value)" but dies if the value does not pass the type
337 constraint.
338 Yes, that's three very similar methods. Blame
340 Moose::Meta::TypeConstraint whose API I'm attempting to emulate.
341 :-)
342 "assert_return($value)"
344 Like "assert_valid($value)" but returns the value if it passes the
345 type constraint.
346 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 "get_message($value)"
352 Returns the error message for the value; even if the value passes
353 the type constraint.
354 "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 The $varname is an optional string like '$foo' indicating the name
361 of the variable being checked.
362 "coerce($value)"
364 Attempt to coerce $value to this type.
365 "assert_coerce($value)"
367 Attempt to coerce $value to this type. Throws an exception if this
368 is not possible.
369 Child type constraint creation and parameterization
371 These methods generate new type constraint objects that inherit from
373 the constraint they are called upon:
374 "create_child_type(%attributes)"
376 Construct a new Type::Tiny object with this object as its parent.
377 "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 HashRef & sub { exists($_->{name}) }
384 Like the "constraint" attribute, this will accept a string of Perl
386 code:
387 HashRef->where('exists($_->{name})')
389 "child_type_class"
391 The class that create_child_type will construct by default.
392 "parameterize(@parameters)"
394 Creates a new parameterized type; throws an exception if called on
395 a non-parameterizable type.
396 "of(@parameters)"
398 A cute alias for "parameterize". Use it like "ArrayRef->of(Int)".
399 "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 "plus_fallback_coercions($type1, $code1, ...)"
406 Like "plus_coercions", but added at a lower priority.
407 "minus_coercions($type1, ...)"
409 Shorthand for creating a new child type constraint with fewer type
410 coercions.
411 "no_coercions"
413 Shorthand for creating a new child type constraint with no
414 coercions at all.
415 Type relationship introspection methods
417 These methods allow you to determine a type constraint's relationship
419 to other type constraints in an organised hierarchy:
420 "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 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 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 "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 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 "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 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 "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 In list context also returns the number of type constraints which
466 had been looped through before the matching constraint was found.
467 "find_constraining_type"
469 Finds the nearest ancestor type constraint (including the type
470 itself) which has a "constraint" coderef.
471 Equivalent to:
473 $type->find_parent(sub { not $_->_is_null_constraint })
475 "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 "type_parameter"
482 In parameterized type constraints, returns the first item on the
483 list of parameters; otherwise returns undef. For example:
484 ( ArrayRef[Int] )->type_parameter; # returns Int
486 ( ArrayRef[Int] )->parent; # returns ArrayRef
487 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 "parameterized_from"
497 Harder to spell alias for "parent" that only works for
498 parameterized types.
499 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 Type relationship introspection function
518 "Type::Tiny::cmp($type1, $type2)"
520 The subtype/supertype relationship between types results in a
521 partial ordering of type constraints.
522 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 List processing methods
535 "grep(@list)"
537 Filters a list to return just the items that pass the type check.
538 @integers = Int->grep(@list);
540 "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 $first_lady = Woman->first(@people);
546 "map(@list)"
548 Coerces a list of items. Only works on types which have a coercion.
549 @truths = Bool->map(@list);
551 "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 @sorted_numbers = Num->sort( Num->grep(@list) );
560 "rsort(@list)"
562 Like "sort" but backwards.
563 "any(@list)"
565 Returns true if any of the list match the type.
566 if ( Int->any(@numbers) ) {
568 say "there was at least one integer";
569 }
570 "all(@list)"
572 Returns true if all of the list match the type.
573 if ( Int->all(@numbers) ) {
575 say "they were all integers";
576 }
577 "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 "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 Inlining methods
589 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 "can_be_inlined"
594 Returns boolean indicating if this type can be inlined.
595 "inline_check($varname)"
597 Creates a type constraint check for a particular variable as a
598 string of Perl code. For example:
599 print( Types::Standard::Num->inline_check('$foo') );
601 prints the following output:
603 (!ref($foo) && Scalar::Util::looks_like_number($foo))
605 For Moose-compat, there is an alias "_inline_check" for this
607 method.
608 "inline_assert($varname)"
610 Much like "inline_check" but outputs a statement of the form:
611 ... or die ...;
613 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 Other methods
624 "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 "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 If Mouse is loaded, then "isa" mocks Mouse::Meta::TypeConstraint.
635 "DOES($role)"
637 Overridden to advertise support for various roles.
638 See also Type::API::Constraint, etc.
640 "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 use Types::Standard qw(Int);
647 tie my @list, Int;
648 push @list, 123, 456; # ok
649 push @list, "Hello"; # dies
650 The following methods exist for Moose/Mouse compatibility, but do not
652 do anything useful.
653 "compile_type_constraint"
655 "hand_optimized_type_constraint"
656 "has_hand_optimized_type_constraint"
657 "inline_environment"
658 "meta"
659 Overloading
661 • Stringification is overloaded to return the qualified name.
662 • Boolification is overloaded to always return true.
664 • Coderefification is overloaded to call "assert_return".
666 • On Perl 5.10.1 and above, smart match is overloaded to call
668 "check".
669 • The "==" operator is overloaded to call "equals".
671 • The "<" and ">" operators are overloaded to call "is_subtype_of"
673 and "is_supertype_of".
674 • The "~" operator is overloaded to call "complementary_type".
676 • The "|" operator is overloaded to build a union of two type
678 constraints. See Type::Tiny::Union.
679 • The "&" operator is overloaded to build the intersection of two
681 type constraints. See Type::Tiny::Intersection.
682 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 Constants
688 "Type::Tiny::SUPPORT_SMARTMATCH"
689 Indicates whether the smart match overload is supported on your
690 version of Perl.
691 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 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 This is a package variable (rather than get/set class methods) to
703 allow for easy localization.
704 $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 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 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 Most normal users can ignore this.
724 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
732 Please report any bugs to
733 <https://github.com/tobyink/p5-type-tiny/issues>.
734
736 The Type::Tiny homepage <https://typetiny.toby.ink/>.
737 Type::Tiny::Manual, Type::API.
739 Type::Library, Type::Utils, Types::Standard, Type::Coercion.
741 Type::Tiny::Class, Type::Tiny::Role, Type::Tiny::Duck,
743 Type::Tiny::Enum, Type::Tiny::Union, Type::Tiny::Intersection.
744 Moose::Meta::TypeConstraint, Mouse::Meta::TypeConstraint.
746 Type::Params.
748 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
757 Toby Inkster <tobyink@cpan.org>.
758
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 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
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.
772perl v5.32.1 2021-04-27 Type::Tiny(3)