1Type::Tiny::Manual::UsiUnsgeWritChoMnotorsieb(u3t)ed PerTlypDeo:c:uTmiennyt:a:tMiaonnual::UsingWithMoose(3)
2
6 Type::Tiny::Manual::UsingWithMoose - how to use Type::Tiny with Moose
7
9 First read Type::Tiny::Manual::Moo, Type::Tiny::Manual::Moo2, and
10 Type::Tiny::Manual::Moo3. Everything in those parts of the manual
11 should work exactly the same in Moose.
12 This part of the manual will focus on Moose-specifics.
14 Why Use Type::Tiny At All?
16 Moose does have a built-in type constraint system which is fairly
17 convenient to use, but there are several reasons you should consider
18 using Type::Tiny instead.
19 • Type::Tiny type constraints will usually be faster than Moose
21 built-ins. Even without Type::Tiny::XS installed, Type::Tiny
22 usually produces more efficient inline code than Moose. Coercions
23 will usually be a lot faster.
24 • Type::Tiny provides helpful methods like "where" and
26 "plus_coercions" that allow type constraints and coercions to be
27 easily tweaked on a per-attribute basis.
28 Something like this is much harder to do with plain Moose types:
30 has name => (
32 is => "ro",
33 isa => Str->plus_coercions(
34 ArrayRef[Str], sub { join " ", @$_ },
35 ),
36 coerce => 1,
37 );
38 Moose tends to encourage defining coercions globally, so if you
40 wanted one Str attribute to be able to coerce from ArrayRef[Str],
41 then all Str attributes would coerce from ArrayRef[Str], and they'd
42 all do that coercion in the same way. (Even if it might make sense
43 to join by a space in some places, a comma in others, and a line
44 break in others!)
45 • Type::Tiny provides automatic deep coercions, so if type Xyz has a
47 coercion, the following should "just work":
48 isa xyzlist => ( is => 'ro', isa => ArrayRef[Xyz], coerce => 1 );
50 • Type::Tiny offers a wider selection of built-in types.
52 • By using Type::Tiny, you can use the same type constraints and
54 coercions for attributes and method parameters, in Moose and non-
55 Moose code.
56 Type::Utils
58 If you've used Moose::Util::TypeConstraints, you may be accustomed to
59 using a DSL for declaring type constraints:
60 use Moose::Util::TypeConstraints;
62 subtype 'Natural',
64 as 'Int',
65 where { $_ > 0 };
66 There's a module called Type::Utils that provides a very similar DSL
68 for declaring types in Type::Library-based type libraries.
69 package My::Types {
71 use Type::Library -base;
72 use Type::Utils;
73 use Types::Standard qw( Int );
74 declare 'Natural',
76 as Int,
77 where { $_ > 0 };
78 }
79 Personally I prefer the more object-oriented way to declare types
81 though.
82 Since Type::Library 1.012, a shortcut has been available for importing
84 Type::Library and Type::Utils at the same time:
85 package MyType {
87 use Type::Library -base, -utils;
88 ...;
90 }
91 In Moose you might also declare types like this within classes and
93 roles too. Unlike Moose, Type::Tiny doesn't keep types in a single
94 global flat namespace, so this doesn't work quite the same with
95 Type::Utils. It still creates the type, but it doesn't store it in any
96 type library; the type is returned.
97 package My::Class {
99 use Moose;
100 use Type::Utils;
101 use Types::Standard qw( Int );
102 my $Natural = # store type in a variable
104 declare 'Natural',
105 as Int,
106 where { $_ > 0 };
107 has number => ( is => 'ro', isa => $Natural );
109 }
110 But really, isn't the object-oriented way cleaner?
112 package My::Class {
114 use Moose;
115 use Types::Standard qw( Int );
116 has number => (
118 is => 'ro',
119 isa => Int->where('$_ > 0'),
120 );
121 }
122 Type::Tiny and MooseX::Types
124 Types::Standard should be a drop-in replacement for MooseX::Types. And
125 Types::Common::Numeric and Types::Common::String should easily replace
126 MooseX::Types::Common::Numeric and MooseX::Types::Common::String.
127 That said, if you do with to use a mixture of Type::Tiny and
129 MooseX::Types, they should fit together pretty seamlessly.
130 use Types::Standard qw( ArrayRef );
132 use MooseX::Types::Common::Numeric qw( PositiveInt );
133 # this should just work
135 my $list_of_nums = ArrayRef[PositiveInt];
136 # and this
138 my $list_or_num = ArrayRef | PositiveInt;
139 "-moose" Import Parameter
141 If you have read this far in the manual, you will know that this is the
142 usual way to import type constraints:
143 use Types::Standard qw( Int );
145 And the "Int" which is imported is a function that takes no arguments
147 and returns the Int type constraint, which is a blessed object in the
148 Type::Tiny class.
149 Type::Tiny mocks the Moose::Meta::TypeConstraint API so well that most
151 Moose and MooseX code will not be able to tell the difference.
152 But what if you need a real Moose::Meta::TypeConstraint object?
154 use Types::Standard -moose, qw( Int );
156 Now the "Int" function imported will return a genuine native Moose type
158 constraint.
159 This flag is mostly a throwback from when Type::Tiny native objects
161 didn't directly work in Moose. In 99.9% of cases, there is no reason to
162 use it and plenty of reasons not to. (Moose native type constraints
163 don't offer helpful methods like "plus_coercions" and "where".)
164 "moose_type" Method
166 Another quick way to get a native Moose type constraint object from a
167 Type::Tiny object is to call the "moose_type" method:
168 use Types::Standard qw( Int );
170 my $tiny_type = Int;
172 my $moose_type = $tiny_type->moose_type;
173 Internally, this is what the "-moose" flag makes imported functions do.
175
177 Here's your next step:
178 • Type::Tiny::Manual::UsingWithMouse
180 How to use Type::Tiny with Mouse, including the advantages of
182 Type::Tiny over built-in type constraints, and Mouse-specific
183 features.
184
186 Toby Inkster <tobyink@cpan.org>.
187
189 This software is copyright (c) 2013-2014, 2017-2021 by Toby Inkster.
190 This is free software; you can redistribute it and/or modify it under
192 the same terms as the Perl 5 programming language system itself.
193
195 THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
196 WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
197 MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
198perl v5.32.1 2021-04-T2y7pe::Tiny::Manual::UsingWithMoose(3)