← Index
NYTProf Performance Profile   « block view • line view • sub view »
For mentat.storage.mongo.pl
  Run on Tue Jun 24 09:58:41 2014
Reported on Tue Jun 24 09:59:35 2014

Filename/usr/local/lib/perl/5.14.2/Moose/Util/TypeConstraints.pm
StatementsExecuted 1934 statements in 7.56ms
Subroutines
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1111.09ms2.91msMoose::Util::TypeConstraints::::BEGIN@33Moose::Util::TypeConstraints::BEGIN@33
111784µs1.72msMoose::Util::TypeConstraints::::BEGIN@36Moose::Util::TypeConstraints::BEGIN@36
111780µs1.85msMoose::Util::TypeConstraints::::BEGIN@39Moose::Util::TypeConstraints::BEGIN@39
111752µs1.63msMoose::Util::TypeConstraints::::BEGIN@37Moose::Util::TypeConstraints::BEGIN@37
111724µs1.92msMoose::Util::TypeConstraints::::BEGIN@38Moose::Util::TypeConstraints::BEGIN@38
10494683µs1.64msMoose::Util::TypeConstraints::::find_type_constraintMoose::Util::TypeConstraints::find_type_constraint
111646µs4.41msMoose::Util::TypeConstraints::::BEGIN@34Moose::Util::TypeConstraints::BEGIN@34
7532578µs2.71msMoose::Util::TypeConstraints::::find_or_parse_type_constraintMoose::Util::TypeConstraints::find_or_parse_type_constraint (recurses: max depth 1, inclusive time 56µs)
111486µs2.07msMoose::Util::TypeConstraints::::BEGIN@42Moose::Util::TypeConstraints::BEGIN@42
17121453µs453µsMoose::Util::TypeConstraints::::CORE:regcompMoose::Util::TypeConstraints::CORE:regcomp (opcode)
2021432µs7.01msMoose::Util::TypeConstraints::::_create_type_constraintMoose::Util::TypeConstraints::_create_type_constraint
7122359µs4.13msMoose::Util::TypeConstraints::::find_or_create_isa_type_constraintMoose::Util::TypeConstraints::find_or_create_isa_type_constraint
7511221µs287µsMoose::Util::TypeConstraints::::normalize_type_constraint_nameMoose::Util::TypeConstraints::normalize_type_constraint_name
1943193µs6.87msMoose::Util::TypeConstraints::::subtypeMoose::Util::TypeConstraints::subtype
1121162µs6.60msMoose::Util::TypeConstraints::::create_class_type_constraintMoose::Util::TypeConstraints::create_class_type_constraint
285166µs66µsMoose::Util::TypeConstraints::::CORE:matchMoose::Util::TypeConstraints::CORE:match (opcode)
751166µs66µsMoose::Util::TypeConstraints::::CORE:substMoose::Util::TypeConstraints::CORE:subst (opcode)
183233µs33µsMoose::Util::TypeConstraints::::asMoose::Util::TypeConstraints::as
11130µs393µsMoose::Util::TypeConstraints::::_create_type_constraint_unionMoose::Util::TypeConstraints::_create_type_constraint_union
172226µs26µsMoose::Util::TypeConstraints::::whereMoose::Util::TypeConstraints::where
42125µs139µsMoose::Util::TypeConstraints::::_detect_type_constraint_unionMoose::Util::TypeConstraints::_detect_type_constraint_union
91124µs5.56msMoose::Util::TypeConstraints::::class_typeMoose::Util::TypeConstraints::class_type
21124µs577µsMoose::Util::TypeConstraints::::_install_type_coercionsMoose::Util::TypeConstraints::_install_type_coercions
11122µs82µsMoose::Util::TypeConstraints::::_parse_type_constraint_unionMoose::Util::TypeConstraints::_parse_type_constraint_union
171120µs20µsMoose::Util::TypeConstraints::::inline_asMoose::Util::TypeConstraints::inline_as
1010113µs13µsMoose::Util::TypeConstraints::::CORE:qrMoose::Util::TypeConstraints::CORE:qr (opcode)
11113µs31µsMoose::Util::TypeConstraints::::BEGIN@614Moose::Util::TypeConstraints::BEGIN@614
21112µs55µsMoose::Util::TypeConstraints::::_detect_parameterized_type_constraintMoose::Util::TypeConstraints::_detect_parameterized_type_constraint
11111µs339µsMoose::Util::TypeConstraints::::typeMoose::Util::TypeConstraints::type
11110µs10µsMoose::Util::TypeConstraints::::BEGIN@40Moose::Util::TypeConstraints::BEGIN@40
1119µs39µsMoose::Util::TypeConstraints::::BEGIN@11Moose::Util::TypeConstraints::BEGIN@11
1119µs20µsMoose::Util::TypeConstraints::::BEGIN@667Moose::Util::TypeConstraints::BEGIN@667
2218µs586µsMoose::Util::TypeConstraints::::coerceMoose::Util::TypeConstraints::coerce
1118µs8µsMoose::Util::TypeConstraints::::BEGIN@3Moose::Util::TypeConstraints::BEGIN@3
1118µs16µsMoose::Util::TypeConstraints::::BEGIN@694Moose::Util::TypeConstraints::BEGIN@694
1118µs17µsMoose::Util::TypeConstraints::::BEGIN@673Moose::Util::TypeConstraints::BEGIN@673
1118µs16µsMoose::Util::TypeConstraints::::BEGIN@678Moose::Util::TypeConstraints::BEGIN@678
1117µs18µsMoose::Util::TypeConstraints::::BEGIN@68Moose::Util::TypeConstraints::BEGIN@68
1117µs12µsMoose::Util::TypeConstraints::::BEGIN@31Moose::Util::TypeConstraints::BEGIN@31
1116µs7µsMoose::Util::TypeConstraints::::list_all_type_constraintsMoose::Util::TypeConstraints::list_all_type_constraints
1116µs33µsMoose::Util::TypeConstraints::::BEGIN@12Moose::Util::TypeConstraints::BEGIN@12
1116µs18µsMoose::Util::TypeConstraints::::BEGIN@13Moose::Util::TypeConstraints::BEGIN@13
1115µs5µsMoose::Util::TypeConstraints::::BEGIN@35Moose::Util::TypeConstraints::BEGIN@35
1115µs398µsMoose::Util::TypeConstraints::::create_type_constraint_unionMoose::Util::TypeConstraints::create_type_constraint_union
1114µs4µsMoose::Util::TypeConstraints::::BEGIN@32Moose::Util::TypeConstraints::BEGIN@32
1114µs4µsMoose::Util::TypeConstraints::::BEGIN@41Moose::Util::TypeConstraints::BEGIN@41
1114µs4µsMoose::Util::TypeConstraints::::BEGIN@10Moose::Util::TypeConstraints::BEGIN@10
2213µs3µsMoose::Util::TypeConstraints::::fromMoose::Util::TypeConstraints::from
2212µs2µsMoose::Util::TypeConstraints::::viaMoose::Util::TypeConstraints::via
0000s0sMoose::Util::TypeConstraints::::__ANON__[:73]Moose::Util::TypeConstraints::__ANON__[:73]
0000s0sMoose::Util::TypeConstraints::::_confessMoose::Util::TypeConstraints::_confess
0000s0sMoose::Util::TypeConstraints::::_create_parameterized_type_constraintMoose::Util::TypeConstraints::_create_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::_parse_parameterized_type_constraintMoose::Util::TypeConstraints::_parse_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::_throw_errorMoose::Util::TypeConstraints::_throw_error
0000s0sMoose::Util::TypeConstraints::::add_parameterizable_typeMoose::Util::TypeConstraints::add_parameterizable_type
0000s0sMoose::Util::TypeConstraints::::create_duck_type_constraintMoose::Util::TypeConstraints::create_duck_type_constraint
0000s0sMoose::Util::TypeConstraints::::create_enum_type_constraintMoose::Util::TypeConstraints::create_enum_type_constraint
0000s0sMoose::Util::TypeConstraints::::create_named_type_constraint_unionMoose::Util::TypeConstraints::create_named_type_constraint_union
0000s0sMoose::Util::TypeConstraints::::create_parameterized_type_constraintMoose::Util::TypeConstraints::create_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::create_role_type_constraintMoose::Util::TypeConstraints::create_role_type_constraint
0000s0sMoose::Util::TypeConstraints::::duck_typeMoose::Util::TypeConstraints::duck_type
0000s0sMoose::Util::TypeConstraints::::enumMoose::Util::TypeConstraints::enum
0000s0sMoose::Util::TypeConstraints::::export_type_constraints_as_functionsMoose::Util::TypeConstraints::export_type_constraints_as_functions
0000s0sMoose::Util::TypeConstraints::::find_or_create_does_type_constraintMoose::Util::TypeConstraints::find_or_create_does_type_constraint
0000s0sMoose::Util::TypeConstraints::::find_or_create_type_constraintMoose::Util::TypeConstraints::find_or_create_type_constraint
0000s0sMoose::Util::TypeConstraints::::get_all_parameterizable_typesMoose::Util::TypeConstraints::get_all_parameterizable_types
0000s0sMoose::Util::TypeConstraints::::get_type_constraint_registryMoose::Util::TypeConstraints::get_type_constraint_registry
0000s0sMoose::Util::TypeConstraints::::list_all_builtin_type_constraintsMoose::Util::TypeConstraints::list_all_builtin_type_constraints
0000s0sMoose::Util::TypeConstraints::::match_on_typeMoose::Util::TypeConstraints::match_on_type
0000s0sMoose::Util::TypeConstraints::::maybe_typeMoose::Util::TypeConstraints::maybe_type
0000s0sMoose::Util::TypeConstraints::::messageMoose::Util::TypeConstraints::message
0000s0sMoose::Util::TypeConstraints::::optimize_asMoose::Util::TypeConstraints::optimize_as
0000s0sMoose::Util::TypeConstraints::::register_type_constraintMoose::Util::TypeConstraints::register_type_constraint
0000s0sMoose::Util::TypeConstraints::::role_typeMoose::Util::TypeConstraints::role_type
0000s0sMoose::Util::TypeConstraints::::unionMoose::Util::TypeConstraints::union
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1
2package Moose::Util::TypeConstraints;
3
# spent 8µs within Moose::Util::TypeConstraints::BEGIN@3 which was called: # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 5
BEGIN {
415µs $Moose::Util::TypeConstraints::AUTHORITY = 'cpan:STEVAN';
5128µs18µs}
# spent 8µs making 1 call to Moose::Util::TypeConstraints::BEGIN@3
6{
721µs $Moose::Util::TypeConstraints::VERSION = '2.1005';
8}
9
10226µs14µs
# spent 4µs within Moose::Util::TypeConstraints::BEGIN@10 which was called: # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 10
use Carp ();
# spent 4µs making 1 call to Moose::Util::TypeConstraints::BEGIN@10
11226µs270µs
# spent 39µs (9+30) within Moose::Util::TypeConstraints::BEGIN@11 which was called: # once (9µs+30µs) by Moose::Meta::Attribute::BEGIN@24 at line 11
use List::MoreUtils qw( all any );
# spent 39µs making 1 call to Moose::Util::TypeConstraints::BEGIN@11 # spent 30µs making 1 call to Exporter::import
12222µs260µs
# spent 33µs (6+27) within Moose::Util::TypeConstraints::BEGIN@12 which was called: # once (6µs+27µs) by Moose::Meta::Attribute::BEGIN@24 at line 12
use Scalar::Util qw( blessed reftype );
# spent 33µs making 1 call to Moose::Util::TypeConstraints::BEGIN@12 # spent 27µs making 1 call to Exporter::import
13248µs230µs
# spent 18µs (6+12) within Moose::Util::TypeConstraints::BEGIN@13 which was called: # once (6µs+12µs) by Moose::Meta::Attribute::BEGIN@24 at line 13
use Moose::Exporter;
# spent 18µs making 1 call to Moose::Util::TypeConstraints::BEGIN@13 # spent 12µs making 1 call to Moose::Exporter::import
14
15## --------------------------------------------------------
16# Prototyped subs must be predeclared because we have a
17# circular dependency with Moose::Meta::Attribute et. al.
18# so in case of us being use'd first the predeclaration
19# ensures the prototypes are in scope when consumers are
20# compiled.
21
22# dah sugah!
23sub where (&);
24sub via (&);
25sub message (&);
26sub optimize_as (&);
27sub inline_as (&);
28
29## --------------------------------------------------------
30
31225µs217µs
# spent 12µs (7+5) within Moose::Util::TypeConstraints::BEGIN@31 which was called: # once (7µs+5µs) by Moose::Meta::Attribute::BEGIN@24 at line 31
use Moose::Deprecated;
32219µs14µs
# spent 4µs within Moose::Util::TypeConstraints::BEGIN@32 which was called: # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 32
use Moose::Meta::TypeConstraint;
# spent 4µs making 1 call to Moose::Util::TypeConstraints::BEGIN@32
332102µs12.91ms
# spent 2.91ms (1.09+1.82) within Moose::Util::TypeConstraints::BEGIN@33 which was called: # once (1.09ms+1.82ms) by Moose::Meta::Attribute::BEGIN@24 at line 33
use Moose::Meta::TypeConstraint::Union;
# spent 2.91ms making 1 call to Moose::Util::TypeConstraints::BEGIN@33
342106µs14.41ms
# spent 4.41ms (646µs+3.76) within Moose::Util::TypeConstraints::BEGIN@34 which was called: # once (646µs+3.76ms) by Moose::Meta::Attribute::BEGIN@24 at line 34
use Moose::Meta::TypeConstraint::Parameterized;
# spent 4.41ms making 1 call to Moose::Util::TypeConstraints::BEGIN@34
35221µs15µs
# spent 5µs within Moose::Util::TypeConstraints::BEGIN@35 which was called: # once (5µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 35
use Moose::Meta::TypeConstraint::Parameterizable;
# spent 5µs making 1 call to Moose::Util::TypeConstraints::BEGIN@35
362113µs11.72ms
# spent 1.72ms (784µs+931µs) within Moose::Util::TypeConstraints::BEGIN@36 which was called: # once (784µs+931µs) by Moose::Meta::Attribute::BEGIN@24 at line 36
use Moose::Meta::TypeConstraint::Class;
# spent 1.72ms making 1 call to Moose::Util::TypeConstraints::BEGIN@36
372101µs11.63ms
# spent 1.63ms (752µs+874µs) within Moose::Util::TypeConstraints::BEGIN@37 which was called: # once (752µs+874µs) by Moose::Meta::Attribute::BEGIN@24 at line 37
use Moose::Meta::TypeConstraint::Role;
# spent 1.63ms making 1 call to Moose::Util::TypeConstraints::BEGIN@37
382115µs11.92ms
# spent 1.92ms (724µs+1.20) within Moose::Util::TypeConstraints::BEGIN@38 which was called: # once (724µs+1.20ms) by Moose::Meta::Attribute::BEGIN@24 at line 38
use Moose::Meta::TypeConstraint::Enum;
# spent 1.92ms making 1 call to Moose::Util::TypeConstraints::BEGIN@38
392113µs11.85ms
# spent 1.85ms (780µs+1.07) within Moose::Util::TypeConstraints::BEGIN@39 which was called: # once (780µs+1.07ms) by Moose::Meta::Attribute::BEGIN@24 at line 39
use Moose::Meta::TypeConstraint::DuckType;
# spent 1.85ms making 1 call to Moose::Util::TypeConstraints::BEGIN@39
40228µs110µs
# spent 10µs within Moose::Util::TypeConstraints::BEGIN@40 which was called: # once (10µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 40
use Moose::Meta::TypeCoercion;
# spent 10µs making 1 call to Moose::Util::TypeConstraints::BEGIN@40
41220µs14µs
# spent 4µs within Moose::Util::TypeConstraints::BEGIN@41 which was called: # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 41
use Moose::Meta::TypeCoercion::Union;
# spent 4µs making 1 call to Moose::Util::TypeConstraints::BEGIN@41
422188µs12.07ms
# spent 2.07ms (486µs+1.58) within Moose::Util::TypeConstraints::BEGIN@42 which was called: # once (486µs+1.58ms) by Moose::Meta::Attribute::BEGIN@24 at line 42
use Moose::Meta::TypeConstraint::Registry;
# spent 2.07ms making 1 call to Moose::Util::TypeConstraints::BEGIN@42
43
4416µs1943µsMoose::Exporter->setup_import_methods(
# spent 943µs making 1 call to Moose::Exporter::setup_import_methods
45 as_is => [
46 qw(
47 type subtype class_type role_type maybe_type duck_type
48 as where message optimize_as inline_as
49 coerce from via
50 enum union
51 find_type_constraint
52 register_type_constraint
53 match_on_type )
54 ],
55);
56
57## --------------------------------------------------------
58## type registry and some useful functions for it
59## --------------------------------------------------------
60
6112µs1216µsmy $REGISTRY = Moose::Meta::TypeConstraint::Registry->new;
# spent 216µs making 1 call to Moose::Meta::TypeConstraint::Registry::new
62
63sub get_type_constraint_registry {$REGISTRY}
6427µs1900ns
# spent 7µs (6+900ns) within Moose::Util::TypeConstraints::list_all_type_constraints which was called: # once (6µs+900ns) by Moose::Meta::Attribute::BEGIN@24 at line 749
sub list_all_type_constraints { keys %{ $REGISTRY->type_constraints } }
65
66sub export_type_constraints_as_functions {
67 my $pkg = caller();
6822.15ms229µs
# spent 18µs (7+11) within Moose::Util::TypeConstraints::BEGIN@68 which was called: # once (7µs+11µs) by Moose::Meta::Attribute::BEGIN@24 at line 68
no strict 'refs';
# spent 18µs making 1 call to Moose::Util::TypeConstraints::BEGIN@68 # spent 11µs making 1 call to strict::unimport
69 foreach my $constraint ( keys %{ $REGISTRY->type_constraints } ) {
70 my $tc = $REGISTRY->get_type_constraint($constraint)
71 ->_compiled_type_constraint;
72 *{"${pkg}::${constraint}"}
73 = sub { $tc->( $_[0] ) ? 1 : undef }; # the undef is for compat
74 }
75}
76
77
# spent 398µs (5+393) within Moose::Util::TypeConstraints::create_type_constraint_union which was called: # once (5µs+393µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 278
sub create_type_constraint_union {
7814µs1393µs _create_type_constraint_union(\@_);
79}
80
81sub create_named_type_constraint_union {
82 my $name = shift;
83 _create_type_constraint_union($name, \@_);
84}
85
86
# spent 393µs (30+363) within Moose::Util::TypeConstraints::_create_type_constraint_union which was called: # once (30µs+363µs) by Moose::Util::TypeConstraints::create_type_constraint_union at line 78
sub _create_type_constraint_union {
871200ns my $name;
881400ns $name = shift if @_ > 1;
8922µs my @tcs = @{ shift() };
90
911200ns my @type_constraint_names;
92
9312µs18µs if ( scalar @tcs == 1 && _detect_type_constraint_union( $tcs[0] ) ) {
9412µs182µs @type_constraint_names = _parse_type_constraint_union( $tcs[0] );
95 }
96 else {
97 @type_constraint_names = @tcs;
98 }
99
1001500ns ( scalar @type_constraint_names >= 2 )
101 || __PACKAGE__->_throw_error(
102 "You must pass in at least 2 type names to make a union");
103
10426µs41µs my @type_constraints = map {
# spent 1µs making 2 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:16], avg 650ns/call # spent 56µs making 2 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 28µs/call, recursion: max depth 1, sum of overlapping time 56µs
10513µs find_or_parse_type_constraint($_)
106 || __PACKAGE__->_throw_error(
107 "Could not locate type constraint ($_) for the union");
108 } @type_constraint_names;
109
11011µs my %options = (
111 type_constraints => \@type_constraints
112 );
1131300ns $options{name} = $name if defined $name;
114
11517µs1215µs return Moose::Meta::TypeConstraint::Union->new(%options);
# spent 215µs making 1 call to Moose::Meta::TypeConstraint::Union::new
116}
117
118
119sub create_parameterized_type_constraint {
120 my $type_constraint_name = shift;
121 my ( $base_type, $type_parameter )
122 = _parse_parameterized_type_constraint($type_constraint_name);
123
124 ( defined $base_type && defined $type_parameter )
125 || __PACKAGE__->_throw_error(
126 "Could not parse type name ($type_constraint_name) correctly");
127
128 if ( $REGISTRY->has_type_constraint($base_type) ) {
129 my $base_type_tc = $REGISTRY->get_type_constraint($base_type);
130 return _create_parameterized_type_constraint(
131 $base_type_tc,
132 $type_parameter
133 );
134 }
135 else {
136 __PACKAGE__->_throw_error(
137 "Could not locate the base type ($base_type)");
138 }
139}
140
141sub _create_parameterized_type_constraint {
142 my ( $base_type_tc, $type_parameter ) = @_;
143 if ( $base_type_tc->can('parameterize') ) {
144 return $base_type_tc->parameterize($type_parameter);
145 }
146 else {
147 return Moose::Meta::TypeConstraint::Parameterized->new(
148 name => $base_type_tc->name . '[' . $type_parameter . ']',
149 parent => $base_type_tc,
150 type_parameter =>
151 find_or_create_isa_type_constraint($type_parameter),
152 );
153 }
154}
155
156#should we also support optimized checks?
157
# spent 6.60ms (162µs+6.44) within Moose::Util::TypeConstraints::create_class_type_constraint which was called 11 times, avg 600µs/call: # 9 times (134µs+5.40ms) by Moose::Util::TypeConstraints::class_type at line 368, avg 615µs/call # 2 times (28µs+1.04ms) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 260, avg 536µs/call
sub create_class_type_constraint {
158115µs my ( $class, $options ) = @_;
159
160# too early for this check
161#find_type_constraint("ClassName")->check($class)
162# || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
163
164119µs my $pkg_defined_in = $options->{package_defined_in} || scalar( caller(1) );
165
1661114µs1149µs if (my $type = $REGISTRY->get_type_constraint($class)) {
# spent 49µs making 11 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 4µs/call
167 if (!($type->isa('Moose::Meta::TypeConstraint::Class') && $type->class eq $class)) {
168 _confess(
169 "The type constraint '$class' has already been created in "
170 . $type->_package_defined_in
171 . " and cannot be created again in "
172 . $pkg_defined_in )
173 }
174 else {
175 return $type;
176 }
177 }
178
179114µs my %options = (
180 class => $class,
181 name => $class,
182 package_defined_in => $pkg_defined_in,
1831127µs %{ $options || {} },
184 );
185
186113µs $options{name} ||= "__ANON__";
187
1881132µs116.20ms my $tc = Moose::Meta::TypeConstraint::Class->new(%options);
# spent 6.20ms making 11 calls to Moose::Meta::TypeConstraint::Class::new, avg 563µs/call
1891117µs11195µs $REGISTRY->add_type_constraint($tc);
# spent 195µs making 11 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 18µs/call
1901132µs return $tc;
191}
192
193sub create_role_type_constraint {
194 my ( $role, $options ) = @_;
195
196# too early for this check
197#find_type_constraint("ClassName")->check($class)
198# || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
199
200 my $pkg_defined_in = $options->{package_defined_in} || scalar( caller(1) );
201
202 if (my $type = $REGISTRY->get_type_constraint($role)) {
203 if (!($type->isa('Moose::Meta::TypeConstraint::Role') && $type->role eq $role)) {
204 _confess(
205 "The type constraint '$role' has already been created in "
206 . $type->_package_defined_in
207 . " and cannot be created again in "
208 . $pkg_defined_in )
209 }
210 else {
211 return $type;
212 }
213 }
214
215 my %options = (
216 role => $role,
217 name => $role,
218 package_defined_in => $pkg_defined_in,
219 %{ $options || {} },
220 );
221
222 $options{name} ||= "__ANON__";
223
224 my $tc = Moose::Meta::TypeConstraint::Role->new(%options);
225 $REGISTRY->add_type_constraint($tc);
226 return $tc;
227}
228
229sub find_or_create_type_constraint {
230 my ( $type_constraint_name, $options_for_anon_type ) = @_;
231
232 if ( my $constraint
233 = find_or_parse_type_constraint($type_constraint_name) ) {
234 return $constraint;
235 }
236 elsif ( defined $options_for_anon_type ) {
237
238 # NOTE:
239 # if there is no $options_for_anon_type
240 # specified, then we assume they don't
241 # want to create one, and return nothing.
242
243 # otherwise assume that we should create
244 # an ANON type with the $options_for_anon_type
245 # options which can be passed in. It should
246 # be noted that these don't get registered
247 # so we need to return it.
248 # - SL
249 return Moose::Meta::TypeConstraint->new(
250 name => '__ANON__',
251 %{$options_for_anon_type}
252 );
253 }
254
255 return;
256}
257
258
# spent 4.13ms (359µs+3.77) within Moose::Util::TypeConstraints::find_or_create_isa_type_constraint which was called 71 times, avg 58µs/call: # 52 times (266µs+3.23ms) by Moose::Meta::Attribute::_process_isa_option at line 374 of Moose/Meta/Attribute.pm, avg 67µs/call # 19 times (92µs+542µs) by Moose::Util::TypeConstraints::_create_type_constraint at line 565, avg 33µs/call
sub find_or_create_isa_type_constraint {
2597131µs my ($type_constraint_name, $options) = @_;
26071263µs1423.77ms find_or_parse_type_constraint($type_constraint_name)
# spent 2.65ms making 71 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 37µs/call # spent 1.07ms making 2 calls to Moose::Util::TypeConstraints::create_class_type_constraint, avg 536µs/call # spent 49µs making 69 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:16], avg 713ns/call
261 || create_class_type_constraint($type_constraint_name, $options);
262}
263
264sub find_or_create_does_type_constraint {
265 my ($type_constraint_name, $options) = @_;
266 find_or_parse_type_constraint($type_constraint_name)
267 || create_role_type_constraint($type_constraint_name, $options);
268}
269
270
# spent 2.71ms (578µs+2.13) within Moose::Util::TypeConstraints::find_or_parse_type_constraint which was called 75 times, avg 36µs/call: # 71 times (547µs+2.11ms) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 260, avg 37µs/call # 2 times (15µs+42µs) by Moose::Meta::TypeCoercion::compile_type_coercion at line 50 of Moose/Meta/TypeCoercion.pm, avg 28µs/call # 2 times (16µs+-16µs) by Moose::Util::TypeConstraints::_create_type_constraint_union at line 104, avg 0s/call
sub find_or_parse_type_constraint {
2717578µs75287µs my $type_constraint_name = normalize_type_constraint_name(shift);
# spent 287µs making 75 calls to Moose::Util::TypeConstraints::normalize_type_constraint_name, avg 4µs/call
272758µs my $constraint;
273
27475203µs1521.49ms if ( $constraint = find_type_constraint($type_constraint_name) ) {
# spent 1.22ms making 75 calls to Moose::Util::TypeConstraints::find_type_constraint, avg 16µs/call # spent 131µs making 3 calls to Moose::Util::TypeConstraints::_detect_type_constraint_union, avg 44µs/call # spent 77µs making 72 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:16], avg 1µs/call # spent 55µs making 2 calls to Moose::Util::TypeConstraints::_detect_parameterized_type_constraint, avg 28µs/call
27572138µs return $constraint;
276 }
277 elsif ( _detect_type_constraint_union($type_constraint_name) ) {
27812µs1398µs $constraint = create_type_constraint_union($type_constraint_name);
279 }
280 elsif ( _detect_parameterized_type_constraint($type_constraint_name) ) {
281 $constraint
282 = create_parameterized_type_constraint($type_constraint_name);
283 }
284 else {
28524µs return;
286 }
287
28811µs120µs $REGISTRY->add_type_constraint($constraint);
28912µs return $constraint;
290}
291
292
# spent 287µs (221+66) within Moose::Util::TypeConstraints::normalize_type_constraint_name which was called 75 times, avg 4µs/call: # 75 times (221µs+66µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 271, avg 4µs/call
sub normalize_type_constraint_name {
2937518µs my $type_constraint_name = shift;
29475186µs7566µs $type_constraint_name =~ s/\s//g;
# spent 66µs making 75 calls to Moose::Util::TypeConstraints::CORE:subst, avg 880ns/call
29575167µs return $type_constraint_name;
296}
297
298sub _confess {
299 my $error = shift;
300
301 local $Carp::CarpLevel = $Carp::CarpLevel + 1;
302 Carp::confess($error);
303}
304
305## --------------------------------------------------------
306## exported functions ...
307## --------------------------------------------------------
308
309
# spent 1.64ms (683µs+961µs) within Moose::Util::TypeConstraints::find_type_constraint which was called 104 times, avg 16µs/call: # 75 times (504µs+718µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 274, avg 16µs/call # 11 times (70µs+97µs) by Moose::Meta::TypeConstraint::Class::new at line 35 of Moose/Meta/TypeConstraint/Class.pm, avg 15µs/call # 11 times (64µs+82µs) by Moose::init_meta at line 165 of Moose.pm, avg 13µs/call # 2 times (13µs+18µs) by Moose::Util::TypeConstraints::_install_type_coercions at line 586, avg 16µs/call # once (7µs+10µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 204 of Moose/Util/TypeConstraints/Builtins.pm # once (7µs+9µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 239 of Moose/Util/TypeConstraints/Builtins.pm # once (7µs+9µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 274 of Moose/Util/TypeConstraints/Builtins.pm # once (6µs+9µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 85 of Moose/Util/TypeConstraints/Builtins.pm # once (6µs+9µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 300 of Moose/Util/TypeConstraints/Builtins.pm
sub find_type_constraint {
31010426µs my $type = shift;
311
312104218µs10446µs if ( blessed $type and $type->isa("Moose::Meta::TypeConstraint") ) {
# spent 46µs making 104 calls to Scalar::Util::blessed, avg 438ns/call
313 return $type;
314 }
315 else {
316104151µs104529µs return unless $REGISTRY->has_type_constraint($type);
# spent 529µs making 104 calls to Moose::Meta::TypeConstraint::Registry::has_type_constraint, avg 5µs/call
31792254µs92387µs return $REGISTRY->get_type_constraint($type);
# spent 387µs making 92 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 4µs/call
318 }
319}
320
321sub register_type_constraint {
322 my $constraint = shift;
323 __PACKAGE__->_throw_error("can't register an unnamed type constraint")
324 unless defined $constraint->name;
325 $REGISTRY->add_type_constraint($constraint);
326 return $constraint;
327}
328
329# type constructors
330
331
# spent 339µs (11+328) within Moose::Util::TypeConstraints::type which was called: # once (11µs+328µs) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 16 of Moose/Util/TypeConstraints/Builtins.pm
sub type {
3321400ns my $name = shift;
333
33456µs my %p = map { %{$_} } @_;
335
33615µs1328µs return _create_type_constraint(
337 $name, undef, $p{where}, $p{message},
338 $p{optimize_as}, $p{inline_as},
339 );
340}
341
342
# spent 6.87ms (193µs+6.68) within Moose::Util::TypeConstraints::subtype which was called 19 times, avg 362µs/call: # 16 times (162µs+5.49ms) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 17 of Moose/Util/TypeConstraints/Builtins.pm, avg 353µs/call # once (11µs+494µs) by MongoDB::BEGIN@32 at line 30 of MongoDB/DBRef.pm # once (9µs+432µs) by MongoDB::BEGIN@32 at line 31 of MongoDB/DBRef.pm # once (12µs+269µs) by MongoDB::Connection::BEGIN@28 at line 148 of MongoDB/MongoClient.pm
sub subtype {
343199µs if ( @_ == 1 && !ref $_[0] ) {
344 __PACKAGE__->_throw_error(
345 'A subtype cannot consist solely of a name, it must have a parent'
346 );
347 }
348
349 # The blessed check is mostly to accommodate MooseX::Types, which
350 # uses an object which overloads stringification as a type name.
351199µs my $name = ref $_[0] && !blessed $_[0] ? undef : shift;
352
35311995µs my %p = map { %{$_} } @_;
354
355 # subtype Str => where { ... };
356197µs if ( !exists $p{as} ) {
3571500ns $p{as} = $name;
3581200ns $name = undef;
359 }
360
3611980µs196.68ms return _create_type_constraint(
# spent 6.68ms making 19 calls to Moose::Util::TypeConstraints::_create_type_constraint, avg 352µs/call
362 $name, $p{as}, $p{where}, $p{message},
363 $p{optimize_as}, $p{inline_as},
364 );
365}
366
367
# spent 5.56ms (24µs+5.53) within Moose::Util::TypeConstraints::class_type which was called 9 times, avg 617µs/call: # 9 times (24µs+5.53ms) by Moose::init_meta at line 165 of Moose.pm, avg 617µs/call
sub class_type {
368921µs95.53ms create_class_type_constraint(@_);
# spent 5.53ms making 9 calls to Moose::Util::TypeConstraints::create_class_type_constraint, avg 615µs/call
369}
370
371sub role_type ($;$) {
372 create_role_type_constraint(@_);
373}
374
375sub maybe_type {
376 my ($type_parameter) = @_;
377
378 register_type_constraint(
379 $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
380 );
381}
382
383sub duck_type {
384 my ( $type_name, @methods ) = @_;
385 if ( ref $type_name eq 'ARRAY' && !@methods ) {
386 @methods = @$type_name;
387 $type_name = undef;
388 }
389 if ( @methods == 1 && ref $methods[0] eq 'ARRAY' ) {
390 @methods = @{ $methods[0] };
391 }
392
393 register_type_constraint(
394 create_duck_type_constraint(
395 $type_name,
396 \@methods,
397 )
398 );
399}
400
401
# spent 586µs (8+577) within Moose::Util::TypeConstraints::coerce which was called 2 times, avg 293µs/call: # once (5µs+346µs) by MongoDB::BEGIN@32 at line 35 of MongoDB/DBRef.pm # once (3µs+231µs) by MongoDB::BEGIN@32 at line 39 of MongoDB/DBRef.pm
sub coerce {
40222µs my ( $type_name, @coercion_map ) = @_;
40326µs2577µs _install_type_coercions( $type_name, \@coercion_map );
# spent 577µs making 2 calls to Moose::Util::TypeConstraints::_install_type_coercions, avg 289µs/call
404}
405
406# The trick of returning @_ lets us avoid having to specify a
407# prototype. Perl will parse this:
408#
409# subtype 'Foo'
410# => as 'Str'
411# => where { ... }
412#
413# as this:
414#
415# subtype( 'Foo', as( 'Str', where { ... } ) );
416#
417# If as() returns all its extra arguments, this just works, and
418# preserves backwards compatibility.
4191850µs
# spent 33µs within Moose::Util::TypeConstraints::as which was called 18 times, avg 2µs/call: # 16 times (27µs+0s) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 18 of Moose/Util/TypeConstraints/Builtins.pm, avg 2µs/call # once (4µs+0s) by MongoDB::BEGIN@32 at line 30 of MongoDB/DBRef.pm # once (2µs+0s) by MongoDB::BEGIN@32 at line 31 of MongoDB/DBRef.pm
sub as { { as => shift }, @_ }
4201740µs
# spent 26µs within Moose::Util::TypeConstraints::where which was called 17 times, avg 2µs/call: # 16 times (23µs+0s) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 19 of Moose/Util/TypeConstraints/Builtins.pm, avg 1µs/call # once (3µs+0s) by MongoDB::Connection::BEGIN@28 at line 148 of MongoDB/MongoClient.pm
sub where (&) { { where => $_[0] } }
421sub message (&) { { message => $_[0] } }
422sub optimize_as (&) { { optimize_as => $_[0] } }
4231734µs
# spent 20µs within Moose::Util::TypeConstraints::inline_as which was called 17 times, avg 1µs/call: # 17 times (20µs+0s) by Moose::Util::TypeConstraints::Builtins::define_builtins at line 21 of Moose/Util/TypeConstraints/Builtins.pm, avg 1µs/call
sub inline_as (&) { { inline_as => $_[0] } }
424
42525µs
# spent 3µs within Moose::Util::TypeConstraints::from which was called 2 times, avg 1µs/call: # once (2µs+0s) by MongoDB::BEGIN@32 at line 35 of MongoDB/DBRef.pm # once (1µs+0s) by MongoDB::BEGIN@32 at line 39 of MongoDB/DBRef.pm
sub from {@_}
42627µs
# spent 2µs within Moose::Util::TypeConstraints::via which was called 2 times, avg 1µs/call: # once (2µs+0s) by MongoDB::BEGIN@32 at line 35 of MongoDB/DBRef.pm # once (900ns+0s) by MongoDB::BEGIN@32 at line 39 of MongoDB/DBRef.pm
sub via (&) { $_[0] }
427
428sub enum {
429 my ( $type_name, @values ) = @_;
430
431 # NOTE:
432 # if only an array-ref is passed then
433 # you get an anon-enum
434 # - SL
435 if ( ref $type_name eq 'ARRAY' ) {
436 @values == 0
437 || __PACKAGE__->_throw_error("enum called with an array reference and additional arguments. Did you mean to parenthesize the enum call's parameters?");
438
439 @values = @$type_name;
440 $type_name = undef;
441 }
442 if ( @values == 1 && ref $values[0] eq 'ARRAY' ) {
443 @values = @{ $values[0] };
444 }
445
446 register_type_constraint(
447 create_enum_type_constraint(
448 $type_name,
449 \@values,
450 )
451 );
452}
453
454sub union {
455 my ( $type_name, @constraints ) = @_;
456 if ( ref $type_name eq 'ARRAY' ) {
457 @constraints == 0
458 || __PACKAGE__->_throw_error("union called with an array reference and additional arguments.");
459 @constraints = @$type_name;
460 $type_name = undef;
461 }
462 if ( @constraints == 1 && ref $constraints[0] eq 'ARRAY' ) {
463 @constraints = @{ $constraints[0] };
464 }
465 if ( defined $type_name ) {
466 return register_type_constraint(
467 create_named_type_constraint_union( $type_name, @constraints )
468 );
469 }
470 return create_type_constraint_union( @constraints );
471}
472
473sub create_enum_type_constraint {
474 my ( $type_name, $values ) = @_;
475
476 Moose::Meta::TypeConstraint::Enum->new(
477 name => $type_name || '__ANON__',
478 values => $values,
479 );
480}
481
482sub create_duck_type_constraint {
483 my ( $type_name, $methods ) = @_;
484
485 Moose::Meta::TypeConstraint::DuckType->new(
486 name => $type_name || '__ANON__',
487 methods => $methods,
488 );
489}
490
491sub match_on_type {
492 my ($to_match, @cases) = @_;
493 my $default;
494 if (@cases % 2 != 0) {
495 $default = pop @cases;
496 (ref $default eq 'CODE')
497 || __PACKAGE__->_throw_error("Default case must be a CODE ref, not $default");
498 }
499 while (@cases) {
500 my ($type, $action) = splice @cases, 0, 2;
501
502 unless (blessed $type && $type->isa('Moose::Meta::TypeConstraint')) {
503 $type = find_or_parse_type_constraint($type)
504 || __PACKAGE__->_throw_error("Cannot find or parse the type '$type'")
505 }
506
507 (ref $action eq 'CODE')
508 || __PACKAGE__->_throw_error("Match action must be a CODE ref, not $action");
509
510 if ($type->check($to_match)) {
511 local $_ = $to_match;
512 return $action->($to_match);
513 }
514 }
515 (defined $default)
516 || __PACKAGE__->_throw_error("No cases matched for $to_match");
517 {
518 local $_ = $to_match;
519 return $default->($to_match);
520 }
521}
522
523
524## --------------------------------------------------------
525## desugaring functions ...
526## --------------------------------------------------------
527
528
# spent 7.01ms (432µs+6.58) within Moose::Util::TypeConstraints::_create_type_constraint which was called 20 times, avg 350µs/call: # 19 times (405µs+6.27ms) by Moose::Util::TypeConstraints::subtype at line 361, avg 352µs/call # once (27µs+301µs) by Moose::Util::TypeConstraints::type at line 336
sub _create_type_constraint ($$$;$$) {
529205µs my $name = shift;
530204µs my $parent = shift;
531204µs my $check = shift;
5322011µs my $message = shift;
533205µs my $optimized = shift;
534203µs my $inlined = shift;
535
5362010µs my $pkg_defined_in = scalar( caller(1) );
537
538206µs if ( defined $name ) {
5391923µs19110µs my $type = $REGISTRY->get_type_constraint($name);
# spent 110µs making 19 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 6µs/call
540
541193µs ( $type->_package_defined_in eq $pkg_defined_in )
542 || _confess(
543 "The type constraint '$name' has already been created in "
544 . $type->_package_defined_in
545 . " and cannot be created again in "
546 . $pkg_defined_in )
547 if defined $type;
548
5491985µs1949µs $name =~ /^[\w:\.]+$/
# spent 49µs making 19 calls to Moose::Util::TypeConstraints::CORE:match, avg 3µs/call
550 or die qq{$name contains invalid characters for a type name.}
551 . qq{ Names can contain alphanumeric character, ":", and "."\n};
552 }
553
5542043µs my %opts = (
555 name => $name,
556 package_defined_in => $pkg_defined_in,
557
558 ( $check ? ( constraint => $check ) : () ),
559 ( $message ? ( message => $message ) : () ),
560 ( $optimized ? ( optimized => $optimized ) : () ),
561 ( $inlined ? ( inlined => $inlined ) : () ),
562 );
563
564202µs my $constraint;
56520102µs57661µs if (
# spent 635µs making 19 calls to Moose::Util::TypeConstraints::find_or_create_isa_type_constraint, avg 33µs/call # spent 15µs making 19 calls to Scalar::Util::blessed, avg 768ns/call # spent 11µs making 19 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:16], avg 605ns/call
566 defined $parent
567 and $parent
568 = blessed $parent
569 ? $parent
570 : find_or_create_isa_type_constraint($parent)
571 ) {
5721938µs195.15ms $constraint = $parent->create_child_type(%opts);
# spent 5.15ms making 19 calls to Moose::Meta::TypeConstraint::create_child_type, avg 271µs/call
573 }
574 else {
57513µs1267µs $constraint = Moose::Meta::TypeConstraint->new(%opts);
# spent 267µs making 1 call to Moose::Meta::TypeConstraint::new
576 }
577
5782029µs19339µs $REGISTRY->add_type_constraint($constraint)
# spent 339µs making 19 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 18µs/call
579 if defined $name;
580
5812049µs return $constraint;
582}
583
584
# spent 577µs (24+553) within Moose::Util::TypeConstraints::_install_type_coercions which was called 2 times, avg 289µs/call: # 2 times (24µs+553µs) by Moose::Util::TypeConstraints::coerce at line 403, avg 289µs/call
sub _install_type_coercions ($$) {
58521µs my ( $type_name, $coercion_map ) = @_;
58622µs231µs my $type = find_type_constraint($type_name);
# spent 31µs making 2 calls to Moose::Util::TypeConstraints::find_type_constraint, avg 16µs/call
5872200ns ( defined $type )
588 || __PACKAGE__->_throw_error(
589 "Cannot find type '$type_name', perhaps you forgot to load it");
59027µs23µs if ( $type->has_coercion ) {
# spent 3µs making 2 calls to Moose::Meta::TypeConstraint::has_coercion, avg 2µs/call
591 $type->coercion->add_type_coercions(@$coercion_map);
592 }
593 else {
59425µs2513µs my $type_coercion = Moose::Meta::TypeCoercion->new(
# spent 513µs making 2 calls to Moose::Meta::TypeCoercion::new, avg 256µs/call
595 type_coercion_map => $coercion_map,
596 type_constraint => $type
597 );
59824µs26µs $type->coercion($type_coercion);
# spent 6µs making 2 calls to Moose::Meta::TypeConstraint::coercion, avg 3µs/call
599 }
600}
601
602## --------------------------------------------------------
603## type notation parsing ...
604## --------------------------------------------------------
605
606{
607
608 # All I have to say is mugwump++ cause I know
609 # do not even have enough regexp-fu to be able
610 # to have written this (I can only barely
611 # understand it as it is)
612 # - SL
613
6143230µs249µs
# spent 31µs (13+18) within Moose::Util::TypeConstraints::BEGIN@614 which was called: # once (13µs+18µs) by Moose::Meta::Attribute::BEGIN@24 at line 614
use re "eval";
# spent 31µs making 1 call to Moose::Util::TypeConstraints::BEGIN@614 # spent 18µs making 1 call to re::import
615
616111µs14µs my $valid_chars = qr{[\w:\.]};
# spent 4µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
617118µs213µs my $type_atom = qr{ (?>$valid_chars+) }x;
# spent 12µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
61813µs1800ns my $ws = qr{ (?>\s*) }x;
# spent 800ns making 1 call to Moose::Util::TypeConstraints::CORE:qr
619115µs211µs my $op_union = qr{ $ws \| $ws }x;
# spent 10µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
620
6211200ns my ($type, $type_capture_parts, $type_with_parameter, $union, $any);
62212µs if (Class::MOP::IS_RUNNING_ON_5_10) {
6231300ns my $type_pattern
624 = q{ (?&type_atom) (?: \[ (?&ws) (?&any) (?&ws) \] )? };
6251200ns my $type_capture_parts_pattern
626 = q{ ((?&type_atom)) (?: \[ (?&ws) ((?&any)) (?&ws) \] )? };
6271100ns my $type_with_parameter_pattern
628 = q{ (?&type_atom) \[ (?&ws) (?&any) (?&ws) \] };
6291200ns my $union_pattern
630 = q{ (?&type) (?> (?: (?&op_union) (?&type) )+ ) };
6311100ns my $any_pattern
632 = q{ (?&type) | (?&union) };
633
634154µs248µs my $defines = qr{(?(DEFINE)
# spent 47µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
635 (?<valid_chars> $valid_chars)
636 (?<type_atom> $type_atom)
637 (?<ws> $ws)
638 (?<op_union> $op_union)
639 (?<type> $type_pattern)
640 (?<type_capture_parts> $type_capture_parts_pattern)
641 (?<type_with_parameter> $type_with_parameter_pattern)
642 (?<union> $union_pattern)
643 (?<any> $any_pattern)
644 )}x;
645
646147µs241µs $type = qr{ $type_pattern $defines }x;
# spent 40µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
647148µs238µs $type_capture_parts = qr{ $type_capture_parts_pattern $defines }x;
# spent 37µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
648146µs240µs $type_with_parameter = qr{ $type_with_parameter_pattern $defines }x;
# spent 39µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
649142µs236µs $union = qr{ $union_pattern $defines }x;
# spent 35µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
650142µs234µs $any = qr{ $any_pattern $defines }x;
# spent 33µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
651 }
652 else {
653 $type
654 = qr{ $type_atom (?: \[ $ws (??{$any}) $ws \] )? }x;
655 $type_capture_parts
656 = qr{ ($type_atom) (?: \[ $ws ((??{$any})) $ws \] )? }x;
657 $type_with_parameter
658 = qr{ $type_atom \[ $ws (??{$any}) $ws \] }x;
659 $union
660 = qr{ $type (?> (?: $op_union $type )+ ) }x;
661 $any
662 = qr{ $type | $union }x;
663 }
664
665
666 sub _parse_parameterized_type_constraint {
667261µs231µs
# spent 20µs (9+11) within Moose::Util::TypeConstraints::BEGIN@667 which was called: # once (9µs+11µs) by Moose::Meta::Attribute::BEGIN@24 at line 667
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 20µs making 1 call to Moose::Util::TypeConstraints::BEGIN@667 # spent 11µs making 1 call to warnings::unimport
668 $_[0] =~ m{ $type_capture_parts }x;
669 return ( $1, $2 );
670 }
671
672
# spent 55µs (12+43) within Moose::Util::TypeConstraints::_detect_parameterized_type_constraint which was called 2 times, avg 28µs/call: # 2 times (12µs+43µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 274, avg 28µs/call
sub _detect_parameterized_type_constraint {
673652µs225µs
# spent 17µs (8+9) within Moose::Util::TypeConstraints::BEGIN@673 which was called: # once (8µs+9µs) by Moose::Meta::Attribute::BEGIN@24 at line 673
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 17µs making 1 call to Moose::Util::TypeConstraints::BEGIN@673 # spent 9µs making 1 call to warnings::unimport
674256µs443µs $_[0] =~ m{ ^ $type_with_parameter $ }x;
# spent 42µs making 2 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 21µs/call # spent 1µs making 2 calls to Moose::Util::TypeConstraints::CORE:match, avg 500ns/call
675 }
676
677
# spent 82µs (22+60) within Moose::Util::TypeConstraints::_parse_type_constraint_union which was called: # once (22µs+60µs) by Moose::Util::TypeConstraints::_create_type_constraint_union at line 94
sub _parse_type_constraint_union {
678499µs225µs
# spent 16µs (8+8) within Moose::Util::TypeConstraints::BEGIN@678 which was called: # once (8µs+8µs) by Moose::Meta::Attribute::BEGIN@24 at line 678
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 16µs making 1 call to Moose::Util::TypeConstraints::BEGIN@678 # spent 8µs making 1 call to warnings::unimport
6791300ns my $given = shift;
6801200ns my @rv;
681164µs256µs while ( $given =~ m{ \G (?: $op_union )? ($type) }gcx ) {
# spent 53µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 4µs making 1 call to Moose::Util::TypeConstraints::CORE:match
682214µs44µs push @rv => $1;
# spent 2µs making 2 calls to Moose::Util::TypeConstraints::CORE:match, avg 1µs/call # spent 2µs making 2 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 800ns/call
683 }
68411µs ( pos($given) eq length($given) )
685 || __PACKAGE__->_throw_error( "'$given' didn't parse (parse-pos="
686 . pos($given)
687 . " and str-length="
688 . length($given)
689 . ")" );
69014µs @rv;
691 }
692
693
# spent 139µs (25+114) within Moose::Util::TypeConstraints::_detect_type_constraint_union which was called 4 times, avg 35µs/call: # 3 times (21µs+110µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 274, avg 44µs/call # once (4µs+4µs) by Moose::Util::TypeConstraints::_create_type_constraint_union at line 93
sub _detect_type_constraint_union {
69410315µs225µs
# spent 16µs (8+8) within Moose::Util::TypeConstraints::BEGIN@694 which was called: # once (8µs+8µs) by Moose::Meta::Attribute::BEGIN@24 at line 694
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 16µs making 1 call to Moose::Util::TypeConstraints::BEGIN@694 # spent 8µs making 1 call to warnings::unimport
6954144µs8114µs $_[0] =~ m{^ $type $op_union $type ( $op_union .* )? $}x;
# spent 103µs making 4 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 26µs/call # spent 11µs making 4 calls to Moose::Util::TypeConstraints::CORE:match, avg 3µs/call
696 }
697}
698
699## --------------------------------------------------------
700# define some basic built-in types
701## --------------------------------------------------------
702
703# By making these classes immutable before creating all the types in
704# Moose::Util::TypeConstraints::Builtin , we avoid repeatedly calling the slow
705# MOP-based accessors.
706$_->make_immutable(
70797µs95µs inline_constructor => 1,
# spent 5µs making 9 calls to Class::MOP::Class::is_mutable, avg 567ns/call
708 constructor_name => "_new",
709
710 # these are Class::MOP accessors, so they need inlining
711 inline_accessors => 1
7121039µs1832.5ms ) for grep { $_->is_mutable }
# spent 32.4ms making 9 calls to Class::MOP::Class::make_immutable, avg 3.60ms/call # spent 30µs making 9 calls to Class::MOP::class_of, avg 3µs/call
713 map { Class::MOP::class_of($_) }
714 qw(
715 Moose::Meta::TypeConstraint
716 Moose::Meta::TypeConstraint::Union
717 Moose::Meta::TypeConstraint::Parameterized
718 Moose::Meta::TypeConstraint::Parameterizable
719 Moose::Meta::TypeConstraint::Class
720 Moose::Meta::TypeConstraint::Role
721 Moose::Meta::TypeConstraint::Enum
722 Moose::Meta::TypeConstraint::DuckType
723 Moose::Meta::TypeConstraint::Registry
724);
725
726189µsrequire Moose::Util::TypeConstraints::Builtins;
72712µs17.69msMoose::Util::TypeConstraints::Builtins::define_builtins($REGISTRY);
728
729my @PARAMETERIZABLE_TYPES
73057µs416µs = map { $REGISTRY->get_type_constraint($_) } qw[ScalarRef ArrayRef HashRef Maybe];
# spent 16µs making 4 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 4µs/call
731
732sub get_all_parameterizable_types {@PARAMETERIZABLE_TYPES}
733
734sub add_parameterizable_type {
735 my $type = shift;
736 ( blessed $type
737 && $type->isa('Moose::Meta::TypeConstraint::Parameterizable') )
738 || __PACKAGE__->_throw_error(
739 "Type must be a Moose::Meta::TypeConstraint::Parameterizable not $type"
740 );
741 push @PARAMETERIZABLE_TYPES => $type;
742}
743
744## --------------------------------------------------------
745# end of built-in types ...
746## --------------------------------------------------------
747
748{
74924µs17µs my @BUILTINS = list_all_type_constraints();
750 sub list_all_builtin_type_constraints {@BUILTINS}
751}
752
753sub _throw_error {
754 shift;
755 require Moose;
756 unshift @_, 'Moose';
757 goto &Moose::throw_error;
758}
759
760125µs1;
761
762# ABSTRACT: Type constraint system for Moose
763
764__END__
 
# spent 66µs within Moose::Util::TypeConstraints::CORE:match which was called 28 times, avg 2µs/call: # 19 times (49µs+0s) by Moose::Util::TypeConstraints::_create_type_constraint at line 549, avg 3µs/call # 4 times (11µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 695, avg 3µs/call # 2 times (2µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 682, avg 1µs/call # 2 times (1µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 674, avg 500ns/call # once (4µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 681
sub Moose::Util::TypeConstraints::CORE:match; # opcode
# spent 13µs within Moose::Util::TypeConstraints::CORE:qr which was called 10 times, avg 1µs/call: # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 616 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 647 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 617 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 649 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 634 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 650 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 646 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 619 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 648 # once (800ns+0s) by Moose::Meta::Attribute::BEGIN@24 at line 618
sub Moose::Util::TypeConstraints::CORE:qr; # opcode
# spent 453µs within Moose::Util::TypeConstraints::CORE:regcomp which was called 17 times, avg 27µs/call: # 4 times (103µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 695, avg 26µs/call # 2 times (42µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 674, avg 21µs/call # 2 times (2µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 682, avg 800ns/call # once (53µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 681 # once (47µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 634 # once (40µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 646 # once (39µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 648 # once (37µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 647 # once (35µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 649 # once (33µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 650 # once (12µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 617 # once (10µs+0s) by Moose::Meta::Attribute::BEGIN@24 at line 619
sub Moose::Util::TypeConstraints::CORE:regcomp; # opcode
# spent 66µs within Moose::Util::TypeConstraints::CORE:subst which was called 75 times, avg 880ns/call: # 75 times (66µs+0s) by Moose::Util::TypeConstraints::normalize_type_constraint_name at line 294, avg 880ns/call
sub Moose::Util::TypeConstraints::CORE:subst; # opcode