← Index
NYTProf Performance Profile   « block view • line view • sub view »
For /usr/bin/epoll_server.pl
  Run on Wed Jan 5 05:34:33 2011
Reported on Wed Jan 5 05:38:04 2011

File /usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm
Statements Executed 2898
Statement Execution Time 62.4ms
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
29213812.2ms31.0msMoose::Util::TypeConstraints::::find_type_constraintMoose::Util::TypeConstraints::find_type_constraint
1114.67ms9.26msMoose::Util::TypeConstraints::::BEGIN@35Moose::Util::TypeConstraints::BEGIN@35
13114.64ms7.27msMoose::Util::TypeConstraints::::__ANON__[:749]Moose::Util::TypeConstraints::__ANON__[:749]
1114.57ms11.2msMoose::Util::TypeConstraints::::BEGIN@29Moose::Util::TypeConstraints::BEGIN@29
1113.89ms4.24msMoose::Util::TypeConstraints::::BEGIN@572Moose::Util::TypeConstraints::BEGIN@572
1113.19ms6.46msMoose::Util::TypeConstraints::::BEGIN@32Moose::Util::TypeConstraints::BEGIN@32
1112.69ms5.70msMoose::Util::TypeConstraints::::BEGIN@33Moose::Util::TypeConstraints::BEGIN@33
60212.65ms10.9msMoose::Util::TypeConstraints::::register_type_constraintMoose::Util::TypeConstraints::register_type_constraint
1112.58ms3.49msMoose::Util::TypeConstraints::::BEGIN@39Moose::Util::TypeConstraints::BEGIN@39
18212.56ms20.2msMoose::Util::TypeConstraints::::_create_type_constraintMoose::Util::TypeConstraints::_create_type_constraint
1112.13ms10.7msMoose::Util::TypeConstraints::::BEGIN@38Moose::Util::TypeConstraints::BEGIN@38
1112.09ms15.2msMoose::Util::TypeConstraints::::BEGIN@30Moose::Util::TypeConstraints::BEGIN@30
1112.08ms9.93msMoose::Util::TypeConstraints::::BEGIN@34Moose::Util::TypeConstraints::BEGIN@34
43211.84ms10.4msMoose::Util::TypeConstraints::::find_or_parse_type_constraintMoose::Util::TypeConstraints::find_or_parse_type_constraint
171711.77ms21.5msMoose::Util::TypeConstraints::::subtypeMoose::Util::TypeConstraints::subtype
34211.51ms21.6msMoose::Util::TypeConstraints::::create_class_type_constraintMoose::Util::TypeConstraints::create_class_type_constraint
9921.49ms1.49msMoose::Util::TypeConstraints::::CORE:regcompMoose::Util::TypeConstraints::CORE:regcomp (opcode)
38331.04ms11.9msMoose::Util::TypeConstraints::::find_or_create_isa_type_constraintMoose::Util::TypeConstraints::find_or_create_isa_type_constraint
2711842µs14.5msMoose::Util::TypeConstraints::::create_role_type_constraintMoose::Util::TypeConstraints::create_role_type_constraint
4311786µs1.56msMoose::Util::TypeConstraints::::normalize_type_constraint_nameMoose::Util::TypeConstraints::normalize_type_constraint_name
3311774µs28.2msMoose::Util::TypeConstraints::::class_typeMoose::Util::TypeConstraints::class_type
2711580µs19.8msMoose::Util::TypeConstraints::::role_typeMoose::Util::TypeConstraints::role_type
4312268µs772µsMoose::Util::TypeConstraints::::CORE:substMoose::Util::TypeConstraints::CORE:subst (opcode)
13131216µs216µsMoose::Util::TypeConstraints::::optimize_asMoose::Util::TypeConstraints::optimize_as
17171197µs197µsMoose::Util::TypeConstraints::::whereMoose::Util::TypeConstraints::where
2032190µs190µsMoose::Util::TypeConstraints::::CORE:matchMoose::Util::TypeConstraints::CORE:match (opcode)
17171154µs154µsMoose::Util::TypeConstraints::::asMoose::Util::TypeConstraints::as
511148µs148µsMoose::Util::TypeConstraints::::get_all_parameterizable_typesMoose::Util::TypeConstraints::get_all_parameterizable_types
511147µs1.56msMoose::Util::TypeConstraints::::find_or_create_type_constraintMoose::Util::TypeConstraints::find_or_create_type_constraint
411137µs802µsMoose::Util::TypeConstraints::::__ANON__[:750]Moose::Util::TypeConstraints::__ANON__[:750]
111105µs160µsMoose::Util::TypeConstraints::::BEGIN@592Moose::Util::TypeConstraints::BEGIN@592
811102µs102µsMoose::Util::TypeConstraints::::__ANON__[:770]Moose::Util::TypeConstraints::__ANON__[:770]
99298µs98µsMoose::Util::TypeConstraints::::CORE:qrMoose::Util::TypeConstraints::CORE:qr (opcode)
11194µs94µsMoose::Util::TypeConstraints::::BEGIN@4Moose::Util::TypeConstraints::BEGIN@4
11168µs1.51msMoose::Util::TypeConstraints::::typeMoose::Util::TypeConstraints::type
11148µs249µsMoose::Util::TypeConstraints::::BEGIN@5Moose::Util::TypeConstraints::BEGIN@5
11141µs143µsMoose::Util::TypeConstraints::::__ANON__[:771]Moose::Util::TypeConstraints::__ANON__[:771]
11134µs34µsMoose::Util::TypeConstraints::::BEGIN@36Moose::Util::TypeConstraints::BEGIN@36
11134µs42µsMoose::Util::TypeConstraints::::list_all_type_constraintsMoose::Util::TypeConstraints::list_all_type_constraints
11132µs75µsMoose::Util::TypeConstraints::::BEGIN@619Moose::Util::TypeConstraints::BEGIN@619
11131µs86µsMoose::Util::TypeConstraints::::BEGIN@65Moose::Util::TypeConstraints::BEGIN@65
11131µs73µsMoose::Util::TypeConstraints::::BEGIN@598Moose::Util::TypeConstraints::BEGIN@598
11131µs78µsMoose::Util::TypeConstraints::::BEGIN@603Moose::Util::TypeConstraints::BEGIN@603
11130µs150µsMoose::Util::TypeConstraints::::BEGIN@6Moose::Util::TypeConstraints::BEGIN@6
11128µs137µsMoose::Util::TypeConstraints::::BEGIN@7Moose::Util::TypeConstraints::BEGIN@7
11123µs23µsMoose::Util::TypeConstraints::::list_all_builtin_type_constraintsMoose::Util::TypeConstraints::list_all_builtin_type_constraints
11122µs22µsMoose::Util::TypeConstraints::::BEGIN@28Moose::Util::TypeConstraints::BEGIN@28
11122µs22µsMoose::Util::TypeConstraints::::BEGIN@31Moose::Util::TypeConstraints::BEGIN@31
11120µs146µsMoose::Util::TypeConstraints::::_detect_type_constraint_unionMoose::Util::TypeConstraints::_detect_type_constraint_union
11120µs20µsMoose::Util::TypeConstraints::::BEGIN@37Moose::Util::TypeConstraints::BEGIN@37
11116µs59µsMoose::Util::TypeConstraints::::_detect_parameterized_type_constraintMoose::Util::TypeConstraints::_detect_parameterized_type_constraint
11113µs13µsMoose::Util::TypeConstraints::::__ANON__[:657]Moose::Util::TypeConstraints::__ANON__[:657]
11110µs10µsMoose::Util::TypeConstraints::::__ANON__[:650]Moose::Util::TypeConstraints::__ANON__[:650]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:277]Moose::Util::TypeConstraints::__ANON__[:277]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:302]Moose::Util::TypeConstraints::__ANON__[:302]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:308]Moose::Util::TypeConstraints::__ANON__[:308]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:653]Moose::Util::TypeConstraints::__ANON__[:653]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:654]Moose::Util::TypeConstraints::__ANON__[:654]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:659]Moose::Util::TypeConstraints::__ANON__[:659]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:662]Moose::Util::TypeConstraints::__ANON__[:662]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:665]Moose::Util::TypeConstraints::__ANON__[:665]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:669]Moose::Util::TypeConstraints::__ANON__[:669]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:672]Moose::Util::TypeConstraints::__ANON__[:672]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:675]Moose::Util::TypeConstraints::__ANON__[:675]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:677]Moose::Util::TypeConstraints::__ANON__[:677]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:680]Moose::Util::TypeConstraints::__ANON__[:680]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:688]Moose::Util::TypeConstraints::__ANON__[:688]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:694]Moose::Util::TypeConstraints::__ANON__[:694]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:698]Moose::Util::TypeConstraints::__ANON__[:698]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:701]Moose::Util::TypeConstraints::__ANON__[:701]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:704]Moose::Util::TypeConstraints::__ANON__[:704]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:709]Moose::Util::TypeConstraints::__ANON__[:709]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:70]Moose::Util::TypeConstraints::__ANON__[:70]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:720]Moose::Util::TypeConstraints::__ANON__[:720]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:728]Moose::Util::TypeConstraints::__ANON__[:728]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:729]Moose::Util::TypeConstraints::__ANON__[:729]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:738]Moose::Util::TypeConstraints::__ANON__[:738]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:759]Moose::Util::TypeConstraints::__ANON__[:759]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:780]Moose::Util::TypeConstraints::__ANON__[:780]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:787]Moose::Util::TypeConstraints::__ANON__[:787]
0000s0sMoose::Util::TypeConstraints::::__ANON__[:788]Moose::Util::TypeConstraints::__ANON__[:788]
0000s0sMoose::Util::TypeConstraints::::_confessMoose::Util::TypeConstraints::_confess
0000s0sMoose::Util::TypeConstraints::::_create_parameterized_type_constraintMoose::Util::TypeConstraints::_create_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::_install_type_coercionsMoose::Util::TypeConstraints::_install_type_coercions
0000s0sMoose::Util::TypeConstraints::::_parse_parameterized_type_constraintMoose::Util::TypeConstraints::_parse_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::_parse_type_constraint_unionMoose::Util::TypeConstraints::_parse_type_constraint_union
0000s0sMoose::Util::TypeConstraints::::_throw_errorMoose::Util::TypeConstraints::_throw_error
0000s0sMoose::Util::TypeConstraints::::add_parameterizable_typeMoose::Util::TypeConstraints::add_parameterizable_type
0000s0sMoose::Util::TypeConstraints::::coerceMoose::Util::TypeConstraints::coerce
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_parameterized_type_constraintMoose::Util::TypeConstraints::create_parameterized_type_constraint
0000s0sMoose::Util::TypeConstraints::::create_type_constraint_unionMoose::Util::TypeConstraints::create_type_constraint_union
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::::fromMoose::Util::TypeConstraints::from
0000s0sMoose::Util::TypeConstraints::::get_type_constraint_registryMoose::Util::TypeConstraints::get_type_constraint_registry
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::::viaMoose::Util::TypeConstraints::via
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
4392µs194µs
# spent 94µs within Moose::Util::TypeConstraints::BEGIN@4 which was called # once (94µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 4
use Carp ();
# spent 94µs making 1 call to Moose::Util::TypeConstraints::BEGIN@4
5397µs2450µs
# spent 249µs (48+201) within Moose::Util::TypeConstraints::BEGIN@5 which was called # once (48µs+201µs) by Moose::Meta::Attribute::BEGIN@18 at line 5
use List::MoreUtils qw( all any );
# spent 249µs making 1 call to Moose::Util::TypeConstraints::BEGIN@5 # spent 201µs making 1 call to Exporter::import
6383µs2270µs
# spent 150µs (30+120) within Moose::Util::TypeConstraints::BEGIN@6 which was called # once (30µs+120µs) by Moose::Meta::Attribute::BEGIN@18 at line 6
use Scalar::Util qw( blessed reftype );
# spent 150µs making 1 call to Moose::Util::TypeConstraints::BEGIN@6 # spent 120µs making 1 call to Exporter::import
73292µs2246µs
# spent 137µs (28+109) within Moose::Util::TypeConstraints::BEGIN@7 which was called # once (28µs+109µs) by Moose::Meta::Attribute::BEGIN@18 at line 7
use Moose::Exporter;
# spent 137µs making 1 call to Moose::Util::TypeConstraints::BEGIN@7 # spent 109µs making 1 call to Moose::Exporter::import
8
914µsour $VERSION = '1.01';
10163µs$VERSION = eval $VERSION;
1113µsour $AUTHORITY = 'cpan:STEVAN';
12
13## --------------------------------------------------------
14# Prototyped subs must be predeclared because we have a
15# circular dependency with Moose::Meta::Attribute et. al.
16# so in case of us being use'd first the predeclaration
17# ensures the prototypes are in scope when consumers are
18# compiled.
19
20# dah sugah!
21sub where (&);
22sub via (&);
23sub message (&);
24sub optimize_as (&);
25
26## --------------------------------------------------------
27
28384µs122µs
# spent 22µs within Moose::Util::TypeConstraints::BEGIN@28 which was called # once (22µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 28
use Moose::Meta::TypeConstraint;
# spent 22µs making 1 call to Moose::Util::TypeConstraints::BEGIN@28
293516µs111.2ms
# spent 11.2ms (4.57+6.62) within Moose::Util::TypeConstraints::BEGIN@29 which was called # once (4.57ms+6.62ms) by Moose::Meta::Attribute::BEGIN@18 at line 29
use Moose::Meta::TypeConstraint::Union;
# spent 11.2ms making 1 call to Moose::Util::TypeConstraints::BEGIN@29
303543µs115.2ms
# spent 15.2ms (2.09+13.1) within Moose::Util::TypeConstraints::BEGIN@30 which was called # once (2.09ms+13.1ms) by Moose::Meta::Attribute::BEGIN@18 at line 30
use Moose::Meta::TypeConstraint::Parameterized;
# spent 15.2ms making 1 call to Moose::Util::TypeConstraints::BEGIN@30
31384µs122µs
# spent 22µs within Moose::Util::TypeConstraints::BEGIN@31 which was called # once (22µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 31
use Moose::Meta::TypeConstraint::Parameterizable;
# spent 22µs making 1 call to Moose::Util::TypeConstraints::BEGIN@31
323930µs16.46ms
# spent 6.46ms (3.19+3.27) within Moose::Util::TypeConstraints::BEGIN@32 which was called # once (3.19ms+3.27ms) by Moose::Meta::Attribute::BEGIN@18 at line 32
use Moose::Meta::TypeConstraint::Class;
# spent 6.46ms making 1 call to Moose::Util::TypeConstraints::BEGIN@32
333401µs15.70ms
# spent 5.70ms (2.69+3.01) within Moose::Util::TypeConstraints::BEGIN@33 which was called # once (2.69ms+3.01ms) by Moose::Meta::Attribute::BEGIN@18 at line 33
use Moose::Meta::TypeConstraint::Role;
# spent 5.70ms making 1 call to Moose::Util::TypeConstraints::BEGIN@33
343566µs19.93ms
# spent 9.93ms (2.08+7.85) within Moose::Util::TypeConstraints::BEGIN@34 which was called # once (2.08ms+7.85ms) by Moose::Meta::Attribute::BEGIN@18 at line 34
use Moose::Meta::TypeConstraint::Enum;
# spent 9.93ms making 1 call to Moose::Util::TypeConstraints::BEGIN@34
3531.74ms19.26ms
# spent 9.26ms (4.67+4.59) within Moose::Util::TypeConstraints::BEGIN@35 which was called # once (4.67ms+4.59ms) by Moose::Meta::Attribute::BEGIN@18 at line 35
use Moose::Meta::TypeConstraint::DuckType;
# spent 9.26ms making 1 call to Moose::Util::TypeConstraints::BEGIN@35
36394µs134µs
# spent 34µs within Moose::Util::TypeConstraints::BEGIN@36 which was called # once (34µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 36
use Moose::Meta::TypeCoercion;
# spent 34µs making 1 call to Moose::Util::TypeConstraints::BEGIN@36
373136µs120µs
# spent 20µs within Moose::Util::TypeConstraints::BEGIN@37 which was called # once (20µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 37
use Moose::Meta::TypeCoercion::Union;
# spent 20µs making 1 call to Moose::Util::TypeConstraints::BEGIN@37
383465µs110.7ms
# spent 10.7ms (2.13+8.52) within Moose::Util::TypeConstraints::BEGIN@38 which was called # once (2.13ms+8.52ms) by Moose::Meta::Attribute::BEGIN@18 at line 38
use Moose::Meta::TypeConstraint::Registry;
# spent 10.7ms making 1 call to Moose::Util::TypeConstraints::BEGIN@38
393730µs13.49ms
# spent 3.49ms (2.58+909µs) within Moose::Util::TypeConstraints::BEGIN@39 which was called # once (2.58ms+909µs) by Moose::Meta::Attribute::BEGIN@18 at line 39
use Moose::Util::TypeConstraints::OptimizedConstraints;
# spent 3.49ms making 1 call to Moose::Util::TypeConstraints::BEGIN@39
40
41130µs16.13msMoose::Exporter->setup_import_methods(
# spent 6.13ms making 1 call to Moose::Exporter::setup_import_methods
42 as_is => [
43 qw(
44 type subtype class_type role_type maybe_type duck_type
45 as where message optimize_as
46 coerce from via
47 enum
48 find_type_constraint
49 register_type_constraint
50 match_on_type )
51 ],
52);
53
54## --------------------------------------------------------
55## type registry and some useful functions for it
56## --------------------------------------------------------
57
58111µs11.87msmy $REGISTRY = Moose::Meta::TypeConstraint::Registry->new;
# spent 1.87ms making 1 call to Moose::Meta::TypeConstraint::Registry::new
59
60sub get_type_constraint_registry {$REGISTRY}
61129µs19µs
# spent 42µs (34+9) within Moose::Util::TypeConstraints::list_all_type_constraints which was called # once (34µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 812
sub list_all_type_constraints { keys %{ $REGISTRY->type_constraints } }
# spent 9µs making 1 call to Moose::Meta::TypeConstraint::Registry::type_constraints
62
63sub export_type_constraints_as_functions {
64 my $pkg = caller();
65311.0ms2141µs
# spent 86µs (31+55) within Moose::Util::TypeConstraints::BEGIN@65 which was called # once (31µs+55µs) by Moose::Meta::Attribute::BEGIN@18 at line 65
no strict 'refs';
# spent 86µs making 1 call to Moose::Util::TypeConstraints::BEGIN@65 # spent 55µs making 1 call to strict::unimport
66 foreach my $constraint ( keys %{ $REGISTRY->type_constraints } ) {
67 my $tc = $REGISTRY->get_type_constraint($constraint)
68 ->_compiled_type_constraint;
69 *{"${pkg}::${constraint}"}
70 = sub { $tc->( $_[0] ) ? 1 : undef }; # the undef is for compat
71 }
72}
73
74sub create_type_constraint_union {
75 my @type_constraint_names;
76
77 if ( scalar @_ == 1 && _detect_type_constraint_union( $_[0] ) ) {
78 @type_constraint_names = _parse_type_constraint_union( $_[0] );
79 }
80 else {
81 @type_constraint_names = @_;
82 }
83
84 ( scalar @type_constraint_names >= 2 )
85 || __PACKAGE__->_throw_error(
86 "You must pass in at least 2 type names to make a union");
87
88 my @type_constraints = map {
89 find_or_parse_type_constraint($_)
90 || __PACKAGE__->_throw_error(
91 "Could not locate type constraint ($_) for the union");
92 } @type_constraint_names;
93
94 return Moose::Meta::TypeConstraint::Union->new(
95 type_constraints => \@type_constraints );
96}
97
98sub create_parameterized_type_constraint {
99 my $type_constraint_name = shift;
100 my ( $base_type, $type_parameter )
101 = _parse_parameterized_type_constraint($type_constraint_name);
102
103 ( defined $base_type && defined $type_parameter )
104 || __PACKAGE__->_throw_error(
105 "Could not parse type name ($type_constraint_name) correctly");
106
107 if ( $REGISTRY->has_type_constraint($base_type) ) {
108 my $base_type_tc = $REGISTRY->get_type_constraint($base_type);
109 return _create_parameterized_type_constraint(
110 $base_type_tc,
111 $type_parameter
112 );
113 }
114 else {
115 __PACKAGE__->_throw_error(
116 "Could not locate the base type ($base_type)");
117 }
118}
119
120sub _create_parameterized_type_constraint {
121 my ( $base_type_tc, $type_parameter ) = @_;
122 if ( $base_type_tc->can('parameterize') ) {
123 return $base_type_tc->parameterize($type_parameter);
124 }
125 else {
126 return Moose::Meta::TypeConstraint::Parameterized->new(
127 name => $base_type_tc->name . '[' . $type_parameter . ']',
128 parent => $base_type_tc,
129 type_parameter =>
130 find_or_create_isa_type_constraint($type_parameter),
131 );
132 }
133}
134
135#should we also support optimized checks?
136
# spent 21.6ms (1.51+20.1) within Moose::Util::TypeConstraints::create_class_type_constraint which was called 34 times, avg 635µs/call: # 33 times (1.49ms+19.9ms) by Moose::Util::TypeConstraints::class_type at line 337, avg 647µs/call # once (21µs+212µs) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 203
sub create_class_type_constraint {
1371361.49ms my ( $class, $options ) = @_;
138
139# too early for this check
140#find_type_constraint("ClassName")->check($class)
141# || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
142
143 my %options = (
144 class => $class,
145 name => $class,
146 %{ $options || {} },
147 );
148
149 $options{name} ||= "__ANON__";
150
151 Moose::Meta::TypeConstraint::Class->new(%options);
# spent 20.1ms making 34 calls to Moose::Meta::TypeConstraint::Class::new, avg 590µs/call
152}
153
154
# spent 14.5ms (842µs+13.6) within Moose::Util::TypeConstraints::create_role_type_constraint which was called 27 times, avg 535µs/call: # 27 times (842µs+13.6ms) by Moose::Util::TypeConstraints::role_type at line 346, avg 535µs/call
sub create_role_type_constraint {
155108845µs my ( $role, $options ) = @_;
156
157# too early for this check
158#find_type_constraint("ClassName")->check($class)
159# || __PACKAGE__->_throw_error("Can't create a class type constraint because '$class' is not a class name");
160
161 my %options = (
162 role => $role,
163 name => $role,
164 %{ $options || {} },
165 );
166
167 $options{name} ||= "__ANON__";
168
169 Moose::Meta::TypeConstraint::Role->new(%options);
# spent 13.6ms making 27 calls to Moose::Meta::TypeConstraint::Role::new, avg 504µs/call
170}
171
172
# spent 1.56ms (147µs+1.41) within Moose::Util::TypeConstraints::find_or_create_type_constraint which was called 5 times, avg 311µs/call: # 5 times (147µs+1.41ms) by MooseX::Types::create_arged_type_constraint at line 429 of MooseX/Types.pm, avg 311µs/call
sub find_or_create_type_constraint {
17310123µs my ( $type_constraint_name, $options_for_anon_type ) = @_;
174
1751105µs101.41ms if ( my $constraint
# spent 1.28ms making 5 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 257µs/call # spent 126µs making 5 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 25µs/call
176 = find_or_parse_type_constraint($type_constraint_name) ) {
177 return $constraint;
178 }
179 elsif ( defined $options_for_anon_type ) {
180
181 # NOTE:
182 # if there is no $options_for_anon_type
183 # specified, then we assume they don't
184 # want to create one, and return nothing.
185
186 # otherwise assume that we should create
187 # an ANON type with the $options_for_anon_type
188 # options which can be passed in. It should
189 # be noted that these don't get registered
190 # so we need to return it.
191 # - SL
192 return Moose::Meta::TypeConstraint->new(
193 name => '__ANON__',
194 %{$options_for_anon_type}
195 );
196 }
197
198 return;
199}
200
201
# spent 11.9ms (1.04+10.9) within Moose::Util::TypeConstraints::find_or_create_isa_type_constraint which was called 38 times, avg 314µs/call: # 17 times (556µs+4.18ms) by Moose::Util::TypeConstraints::_create_type_constraint at line 523, avg 278µs/call # 16 times (349µs+3.77ms) by Moose::Meta::Attribute::_process_options at line 307 of Moose/Meta/Attribute.pm, avg 257µs/call # 5 times (138µs+2.95ms) by Moose::Meta::TypeConstraint::Parameterizable::_parse_type_parameter at line 47 of Moose/Meta/TypeConstraint/Parameterizable.pm, avg 618µs/call
sub find_or_create_isa_type_constraint {
20276611µs my $type_constraint_name = shift;
2031436µs7610.9ms find_or_parse_type_constraint($type_constraint_name)
# spent 9.07ms making 38 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 239µs/call # spent 942µs making 32 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 29µs/call # spent 651µs making 5 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:21], avg 130µs/call # spent 234µs making 1 call to Moose::Util::TypeConstraints::create_class_type_constraint
204 || create_class_type_constraint($type_constraint_name);
205}
206
207sub find_or_create_does_type_constraint {
208 my $type_constraint_name = shift;
209 find_or_parse_type_constraint($type_constraint_name)
210 || create_role_type_constraint($type_constraint_name);
211}
212
213
# spent 10.4ms (1.84+8.52) within Moose::Util::TypeConstraints::find_or_parse_type_constraint which was called 43 times, avg 241µs/call: # 38 times (1.59ms+7.48ms) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 203, avg 239µs/call # 5 times (247µs+1.04ms) by Moose::Util::TypeConstraints::find_or_create_type_constraint at line 175, avg 257µs/call
sub find_or_parse_type_constraint {
2141291.42ms431.56ms my $type_constraint_name = normalize_type_constraint_name(shift);
# spent 1.56ms making 43 calls to Moose::Util::TypeConstraints::normalize_type_constraint_name, avg 36µs/call
215 my $constraint;
216
2171500µs876.96ms if ( $constraint = find_type_constraint($type_constraint_name) ) {
# spent 4.89ms making 43 calls to Moose::Util::TypeConstraints::find_type_constraint, avg 114µs/call # spent 1.24ms making 37 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 33µs/call # spent 626µs making 5 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:21], avg 125µs/call # spent 146µs making 1 call to Moose::Util::TypeConstraints::_detect_type_constraint_union # spent 59µs making 1 call to Moose::Util::TypeConstraints::_detect_parameterized_type_constraint
218 return $constraint;
219 }
220 elsif ( _detect_type_constraint_union($type_constraint_name) ) {
221 $constraint = create_type_constraint_union($type_constraint_name);
222 }
223 elsif ( _detect_parameterized_type_constraint($type_constraint_name) ) {
224 $constraint
225 = create_parameterized_type_constraint($type_constraint_name);
226 }
227 else {
228 return;
229 }
230
231 $REGISTRY->add_type_constraint($constraint);
232 return $constraint;
233}
234
235
# spent 1.56ms (786µs+772µs) within Moose::Util::TypeConstraints::normalize_type_constraint_name which was called 43 times, avg 36µs/call: # 43 times (786µs+772µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 214, avg 36µs/call
sub normalize_type_constraint_name {
2361291.10ms my $type_constraint_name = shift;
237148µs481.28ms $type_constraint_name =~ s/\s//g;
# spent 772µs making 43 calls to Moose::Util::TypeConstraints::CORE:subst, avg 18µs/call # spent 504µs making 5 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:21], avg 101µs/call
238 return $type_constraint_name;
239}
240
241sub _confess {
242 my $error = shift;
243
244 local $Carp::CarpLevel = $Carp::CarpLevel + 1;
245 Carp::confess($error);
246}
247
248## --------------------------------------------------------
249## exported functions ...
250## --------------------------------------------------------
251
252
# spent 31.0ms (12.2+18.8) within Moose::Util::TypeConstraints::find_type_constraint which was called 292 times, avg 106µs/call: # 66 times (2.69ms+5.21ms) by MooseX::Types::Base::import at line 64 of MooseX/Types/Base.pm, avg 120µs/call # 43 times (1.72ms+3.17ms) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217, avg 114µs/call # 35 times (809µs+355µs) by Moose::Meta::TypeConstraint::equals at line 134 of Moose/Meta/TypeConstraint.pm, avg 33µs/call # 34 times (1.63ms+2.41ms) by Moose::Meta::TypeConstraint::Class::new at line 23 of Moose/Meta/TypeConstraint/Class.pm, avg 119µs/call # 34 times (1.43ms+1.99ms) by Moose::init_meta at line 155 of Moose.pm, avg 100µs/call # 29 times (2.04ms+2.20ms) by Moose::Role::init_meta at line 116 of Moose/Role.pm, avg 146µs/call # 27 times (978µs+1.72ms) by Moose::Meta::TypeConstraint::Role::new at line 23 of Moose/Meta/TypeConstraint/Role.pm, avg 100µs/call # 11 times (389µs+775µs) by Moose::Meta::TypeConstraint::is_subtype_of at line 165 of Moose/Meta/TypeConstraint.pm, avg 106µs/call # 9 times (352µs+752µs) by MooseX::Types::create_base_type_constraint at line 452 of MooseX/Types.pm, avg 123µs/call # once (48µs+58µs) by Moose::Meta::Attribute::BEGIN@18 at line 731 # once (36µs+56µs) by Moose::Meta::Attribute::BEGIN@18 at line 752 # once (35µs+56µs) by Moose::Meta::Attribute::BEGIN@18 at line 790 # once (35µs+55µs) by Moose::Meta::Attribute::BEGIN@18 at line 773
sub find_type_constraint {
2535846.98ms my $type = shift;
254
2554436.28ms3322.05ms if ( blessed $type and $type->isa("Moose::Meta::TypeConstraint") ) {
# spent 1.51ms making 292 calls to Scalar::Util::blessed, avg 5µs/call # spent 335µs making 5 calls to MooseX::Types::TypeDecorator::isa, avg 67µs/call # spent 199µs making 35 calls to UNIVERSAL::isa, avg 6µs/call
256 return $type;
257 }
258 else {
259 return unless $REGISTRY->has_type_constraint($type);
# spent 10.6ms making 252 calls to Moose::Meta::TypeConstraint::Registry::has_type_constraint, avg 42µs/call
260 return $REGISTRY->get_type_constraint($type);
# spent 6.18ms making 191 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 32µs/call
261 }
262}
263
264
# spent 10.9ms (2.65+8.25) within Moose::Util::TypeConstraints::register_type_constraint which was called 60 times, avg 182µs/call: # 33 times (1.55ms+4.54ms) by Moose::Util::TypeConstraints::class_type at line 337, avg 185µs/call # 27 times (1.10ms+3.72ms) by Moose::Util::TypeConstraints::role_type at line 346, avg 178µs/call
sub register_type_constraint {
2652401.89ms my $constraint = shift;
266 __PACKAGE__->_throw_error("can't register an unnamed type constraint")
# spent 653µs making 60 calls to Moose::Meta::TypeConstraint::name, avg 11µs/call
267 unless defined $constraint->name;
268 $REGISTRY->add_type_constraint($constraint);
# spent 7.60ms making 60 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 127µs/call
269 return $constraint;
270}
271
272# type constructors
273
274
# spent 1.51ms (68µs+1.44) within Moose::Util::TypeConstraints::type which was called # once (68µs+1.44ms) by Moose::Meta::Attribute::BEGIN@18 at line 650
sub type {
275
276 # back-compat version, called without sugar
2776207µs3151µs if ( !any { ( reftype($_) || '' ) eq 'HASH' } @_ ) {
# spent 139µs making 1 call to List::MoreUtils::any # spent 12µs making 2 calls to Scalar::Util::reftype, avg 6µs/call
278 return _create_type_constraint( $_[0], undef, $_[1] );
279 }
280
281 my $name = shift;
282
283 my %p = map { %{$_} } @_;
284
285 return _create_type_constraint(
# spent 1.30ms making 1 call to Moose::Util::TypeConstraints::_create_type_constraint
286 $name, undef, $p{where}, $p{message},
287 $p{optimize_as}
288 );
289}
290
291
# spent 21.5ms (1.77+19.7) within Moose::Util::TypeConstraints::subtype which was called 17 times, avg 1.26ms/call: # once (134µs+1.96ms) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (90µs+1.71ms) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (141µs+1.59ms) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (88µs+1.44ms) by Moose::Meta::Attribute::BEGIN@18 at line 651 # once (91µs+1.26ms) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (256µs+1.09ms) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (147µs+1.16ms) by Moose::Meta::Attribute::BEGIN@18 at line 653 # once (80µs+1.19ms) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (80µs+1.08ms) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (85µs+970µs) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (79µs+965µs) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (86µs+957µs) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (86µs+902µs) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (82µs+863µs) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (84µs+850µs) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (80µs+845µs) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (81µs+840µs) by Moose::Meta::Attribute::BEGIN@18 at line 663
sub subtype {
292
293 # crazy back-compat code for being called without sugar ...
294 #
295 # subtype 'Parent', sub { where };
2961361.79ms15µs if ( scalar @_ == 2 && ( reftype( $_[1] ) || '' ) eq 'CODE' ) {
# spent 5µs making 1 call to Scalar::Util::reftype
297 return _create_type_constraint( undef, @_ );
298 }
299
300 # subtype 'Parent', sub { where }, sub { message };
301 # subtype 'Parent', sub { where }, sub { message }, sub { optimized };
30216468µs32571µs if ( scalar @_ >= 3 && all { ( reftype($_) || '' ) eq 'CODE' }
# spent 493µs making 16 calls to List::MoreUtils::all, avg 31µs/call # spent 78µs making 16 calls to Scalar::Util::reftype, avg 5µs/call
303 @_[ 1 .. $#_ ] ) {
304 return _create_type_constraint( undef, @_ );
305 }
306
307 # subtype 'Name', 'Parent', ...
30834354µs17303µs if ( scalar @_ >= 2 && all { !ref } @_[ 0, 1 ] ) {
# spent 303µs making 17 calls to List::MoreUtils::all, avg 18µs/call
309 return _create_type_constraint(@_);
310 }
311
312 if ( @_ == 1 && !ref $_[0] ) {
313 __PACKAGE__->_throw_error(
314 'A subtype cannot consist solely of a name, it must have a parent'
315 );
316 }
317
318 # The blessed check is mostly to accommodate MooseX::Types, which
319 # uses an object which overloads stringification as a type name.
320 my $name = ref $_[0] && !blessed $_[0] ? undef : shift;
321
322 my %p = map { %{$_} } @_;
323
324 # subtype Str => where { ... };
325 if ( !exists $p{as} ) {
326 $p{as} = $name;
327 $name = undef;
328 }
329
330 return _create_type_constraint(
# spent 18.9ms making 17 calls to Moose::Util::TypeConstraints::_create_type_constraint, avg 1.11ms/call
331 $name, $p{as}, $p{where}, $p{message},
332 $p{optimize_as}
333 );
334}
335
336
# spent 28.2ms (774µs+27.4) within Moose::Util::TypeConstraints::class_type which was called 33 times, avg 855µs/call: # 33 times (774µs+27.4ms) by Moose::init_meta at line 155 of Moose.pm, avg 855µs/call
sub class_type {
33733924µs6627.4ms register_type_constraint(
# spent 21.4ms making 33 calls to Moose::Util::TypeConstraints::create_class_type_constraint, avg 647µs/call # spent 6.09ms making 33 calls to Moose::Util::TypeConstraints::register_type_constraint, avg 185µs/call
338 create_class_type_constraint(
339 $_[0],
340 ( defined( $_[1] ) ? $_[1] : () ),
341 )
342 );
343}
344
345
# spent 19.8ms (580µs+19.3) within Moose::Util::TypeConstraints::role_type which was called 27 times, avg 735µs/call: # 27 times (580µs+19.3ms) by Moose::Role::init_meta at line 116 of Moose/Role.pm, avg 735µs/call
sub role_type ($;$) {
34627478µs5419.3ms register_type_constraint(
# spent 14.5ms making 27 calls to Moose::Util::TypeConstraints::create_role_type_constraint, avg 535µs/call # spent 4.81ms making 27 calls to Moose::Util::TypeConstraints::register_type_constraint, avg 178µs/call
347 create_role_type_constraint(
348 $_[0],
349 ( defined( $_[1] ) ? $_[1] : () ),
350 )
351 );
352}
353
354sub maybe_type {
355 my ($type_parameter) = @_;
356
357 register_type_constraint(
358 $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
359 );
360}
361
362sub duck_type {
363 my ( $type_name, @methods ) = @_;
364 if ( ref $type_name eq 'ARRAY' && !@methods ) {
365 @methods = @$type_name;
366 $type_name = undef;
367 }
368 if ( @methods == 1 && ref $methods[0] eq 'ARRAY' ) {
369 @methods = @{ $methods[0] };
370 }
371
372 register_type_constraint(
373 create_duck_type_constraint(
374 $type_name,
375 \@methods,
376 )
377 );
378}
379
380sub coerce {
381 my ( $type_name, @coercion_map ) = @_;
382 _install_type_coercions( $type_name, \@coercion_map );
383}
384
385# The trick of returning @_ lets us avoid having to specify a
386# prototype. Perl will parse this:
387#
388# subtype 'Foo'
389# => as 'Str'
390# => where { ... }
391#
392# as this:
393#
394# subtype( 'Foo', as( 'Str', where { ... } ) );
395#
396# If as() returns all it's extra arguments, this just works, and
397# preserves backwards compatibility.
39817296µs
# spent 154µs within Moose::Util::TypeConstraints::as which was called 17 times, avg 9µs/call: # once (14µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (10µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 651 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 653 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699
sub as { { as => shift }, @_ }
39917236µs
# spent 197µs within Moose::Util::TypeConstraints::where which was called 17 times, avg 12µs/call: # once (66µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 # once (12µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 650 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (9µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 653 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666
sub where (&) { { where => $_[0] } }
400sub message (&) { { message => $_[0] } }
40113280µs
# spent 216µs within Moose::Util::TypeConstraints::optimize_as which was called 13 times, avg 17µs/call: # once (133µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688
sub optimize_as (&) { { optimize_as => $_[0] } }
402
403sub from {@_}
404sub via (&) { $_[0] }
405
406sub enum {
407 my ( $type_name, @values ) = @_;
408
409 # NOTE:
410 # if only an array-ref is passed then
411 # you get an anon-enum
412 # - SL
413 if ( ref $type_name eq 'ARRAY' && !@values ) {
414 @values = @$type_name;
415 $type_name = undef;
416 }
417 if ( @values == 1 && ref $values[0] eq 'ARRAY' ) {
418 @values = @{ $values[0] };
419 }
420 ( scalar @values >= 2 )
421 || __PACKAGE__->_throw_error(
422 "You must have at least two values to enumerate through");
423 my %valid = map { $_ => 1 } @values;
424
425 register_type_constraint(
426 create_enum_type_constraint(
427 $type_name,
428 \@values,
429 )
430 );
431}
432
433sub create_enum_type_constraint {
434 my ( $type_name, $values ) = @_;
435
436 Moose::Meta::TypeConstraint::Enum->new(
437 name => $type_name || '__ANON__',
438 values => $values,
439 );
440}
441
442sub create_duck_type_constraint {
443 my ( $type_name, $methods ) = @_;
444
445 Moose::Meta::TypeConstraint::DuckType->new(
446 name => $type_name || '__ANON__',
447 methods => $methods,
448 );
449}
450
451sub match_on_type {
452 my ($to_match, @cases) = @_;
453 my $default;
454 if (@cases % 2 != 0) {
455 $default = pop @cases;
456 (ref $default eq 'CODE')
457 || __PACKAGE__->_throw_error("Default case must be a CODE ref, not $default");
458 }
459 while (@cases) {
460 my ($type, $action) = splice @cases, 0, 2;
461
462 unless (blessed $type && $type->isa('Moose::Meta::TypeConstraint')) {
463 $type = find_or_parse_type_constraint($type)
464 || __PACKAGE__->_throw_error("Cannot find or parse the type '$type'")
465 }
466
467 (ref $action eq 'CODE')
468 || __PACKAGE__->_throw_error("Match action must be a CODE ref, not $action");
469
470 if ($type->check($to_match)) {
471 local $_ = $to_match;
472 return $action->($to_match);
473 }
474 }
475 (defined $default)
476 || __PACKAGE__->_throw_error("No cases matched for $to_match");
477 {
478 local $_ = $to_match;
479 return $default->($to_match);
480 }
481}
482
483
484## --------------------------------------------------------
485## desugaring functions ...
486## --------------------------------------------------------
487
488
# spent 20.2ms (2.56+17.6) within Moose::Util::TypeConstraints::_create_type_constraint which was called 18 times, avg 1.12ms/call: # 17 times (2.44ms+16.4ms) by Moose::Util::TypeConstraints::subtype at line 330, avg 1.11ms/call # once (125µs+1.18ms) by Moose::Util::TypeConstraints::type at line 285
sub _create_type_constraint ($$$;$$) {
4892161.65ms my $name = shift;
490 my $parent = shift;
491 my $check = shift;
492 my $message = shift;
493 my $optimized = shift;
494
495 my $pkg_defined_in = scalar( caller(1) );
496
49754533µs if ( defined $name ) {
498 my $type = $REGISTRY->get_type_constraint($name);
# spent 590µs making 18 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 33µs/call
499
500 ( $type->_package_defined_in eq $pkg_defined_in )
501 || _confess(
502 "The type constraint '$name' has already been created in "
503 . $type->_package_defined_in
504 . " and cannot be created again in "
505 . $pkg_defined_in )
506 if defined $type;
507
508 $name =~ /^[\w:\.]+$/
# spent 186µs making 18 calls to Moose::Util::TypeConstraints::CORE:match, avg 10µs/call
509 or die qq{$name contains invalid characters for a type name.}
510 . qq{ Names can contain alphanumeric character, ":", and "."\n};
511 }
512
513 my %opts = (
514 name => $name,
515 package_defined_in => $pkg_defined_in,
516
517 ( $check ? ( constraint => $check ) : () ),
518 ( $message ? ( message => $message ) : () ),
519 ( $optimized ? ( optimized => $optimized ) : () ),
520 );
521
522 my $constraint;
5231255µs6813.1ms if (
# spent 6.80ms making 17 calls to Moose::Meta::TypeConstraint::create_child_type, avg 400µs/call # spent 4.73ms making 17 calls to Moose::Util::TypeConstraints::find_or_create_isa_type_constraint, avg 278µs/call # spent 1.50ms making 17 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 88µs/call # spent 85µs making 17 calls to Scalar::Util::blessed, avg 5µs/call
524 defined $parent
525 and $parent
526 = blessed $parent
527 ? $parent
528 : find_or_create_isa_type_constraint($parent)
529 ) {
530 $constraint = $parent->create_child_type(%opts);
531 }
532 else {
533 $constraint = Moose::Meta::TypeConstraint->new(%opts);
# spent 995µs making 1 call to Moose::Meta::TypeConstraint::new
534 }
535
536 $REGISTRY->add_type_constraint($constraint)
# spent 2.75ms making 18 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 153µs/call
537 if defined $name;
538
539 return $constraint;
540}
541
542sub _install_type_coercions ($$) {
543 my ( $type_name, $coercion_map ) = @_;
544 my $type = find_type_constraint($type_name);
545 ( defined $type )
546 || __PACKAGE__->_throw_error(
547 "Cannot find type '$type_name', perhaps you forgot to load it");
548 if ( $type->has_coercion ) {
549 $type->coercion->add_type_coercions(@$coercion_map);
550 }
551 else {
552 my $type_coercion = Moose::Meta::TypeCoercion->new(
553 type_coercion_map => $coercion_map,
554 type_constraint => $type
555 );
556 $type->coercion($type_coercion);
557 }
558}
559
560## --------------------------------------------------------
561## type notation parsing ...
562## --------------------------------------------------------
563
564{
565
566 # All I have to say is mugwump++ cause I know
567 # do not even have enough regexp-fu to be able
568 # to have written this (I can only barely
569 # understand it as it is)
570 # - SL
571
5724955µs64.36ms
# spent 4.24ms (3.89+348µs) within Moose::Util::TypeConstraints::BEGIN@572 which was called # once (3.89ms+348µs) by Moose::Meta::Attribute::BEGIN@18 at line 572
use re "eval";
# spent 4.24ms making 1 call to Moose::Util::TypeConstraints::BEGIN@572 # spent 65µs making 1 call to re::import # spent 52µs making 4 calls to Regexp::DESTROY, avg 13µs/call
573
574101.73ms115µs my $valid_chars = qr{[\w:\.]};
# spent 15µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
575 my $type_atom = qr{ (?>$valid_chars+) }x;
# spent 48µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 5µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
576 my $ws = qr{ (?>\s*) }x;
# spent 42µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
577
578 my $any;
579
580 my $type = qr{ $type_atom (?: \[ $ws (??{$any}) $ws \] )? }x;
# spent 305µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 7µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
581 my $type_capture_parts
# spent 296µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 6µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
582 = qr{ ($type_atom) (?: \[ $ws ((??{$any})) $ws \] )? }x;
583 my $type_with_parameter
# spent 151µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 6µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
584 = qr{ $type_atom \[ $ws (??{$any}) $ws \] }x;
585
586 my $op_union = qr{ $ws \| $ws }x;
# spent 30µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 5µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
587 my $union = qr{ $type (?> (?: $op_union $type )+ ) }x;
# spent 193µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 6µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
588
589 $any = qr{ $type | $union }x;
# spent 300µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 7µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
590
591 sub _parse_parameterized_type_constraint {
5923200µs2215µs
# spent 160µs (105+55) within Moose::Util::TypeConstraints::BEGIN@592 which was called # once (105µs+55µs) by Moose::Meta::Attribute::BEGIN@18 at line 592
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 160µs making 1 call to Moose::Util::TypeConstraints::BEGIN@592 # spent 55µs making 1 call to warnings::unimport
593 $_[0] =~ m{ $type_capture_parts }x;
594 return ( $1, $2 );
595 }
596
597
# spent 59µs (16+43) within Moose::Util::TypeConstraints::_detect_parameterized_type_constraint which was called # once (16µs+43µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217
sub _detect_parameterized_type_constraint {
5986230µs2115µs
# spent 73µs (31+42) within Moose::Util::TypeConstraints::BEGIN@598 which was called # once (31µs+42µs) by Moose::Meta::Attribute::BEGIN@18 at line 598
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 73µs making 1 call to Moose::Util::TypeConstraints::BEGIN@598 # spent 42µs making 1 call to warnings::unimport
599 $_[0] =~ m{ ^ $type_with_parameter $ }x;
# spent 42µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:match
600 }
601
602 sub _parse_type_constraint_union {
6033400µs2125µs
# spent 78µs (31+47) within Moose::Util::TypeConstraints::BEGIN@603 which was called # once (31µs+47µs) by Moose::Meta::Attribute::BEGIN@18 at line 603
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 78µs making 1 call to Moose::Util::TypeConstraints::BEGIN@603 # spent 47µs making 1 call to warnings::unimport
604 my $given = shift;
605 my @rv;
606 while ( $given =~ m{ \G (?: $op_union )? ($type) }gcx ) {
607 push @rv => $1;
608 }
609 ( pos($given) eq length($given) )
610 || __PACKAGE__->_throw_error( "'$given' didn't parse (parse-pos="
611 . pos($given)
612 . " and str-length="
613 . length($given)
614 . ")" );
615 @rv;
616 }
617
618
# spent 146µs (20+126) within Moose::Util::TypeConstraints::_detect_type_constraint_union which was called # once (20µs+126µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217
sub _detect_type_constraint_union {
61966.32ms2119µs
# spent 75µs (32+44) within Moose::Util::TypeConstraints::BEGIN@619 which was called # once (32µs+44µs) by Moose::Meta::Attribute::BEGIN@18 at line 619
{ no warnings 'void'; $any; } # force capture of interpolated lexical
# spent 75µs making 1 call to Moose::Util::TypeConstraints::BEGIN@619 # spent 44µs making 1 call to warnings::unimport
620 $_[0] =~ m{^ $type $op_union $type ( $op_union .* )? $}x;
# spent 124µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 2µs making 1 call to Moose::Util::TypeConstraints::CORE:match
621 }
622}
623
624## --------------------------------------------------------
625# define some basic built-in types
626## --------------------------------------------------------
627
628# By making these classes immutable before creating all the types we
629# below, we avoid repeatedly calling the slow MOP-based accessors.
630$_->make_immutable(
631 inline_constructor => 1,
# spent 47µs making 9 calls to Class::MOP::Class::is_mutable, avg 5µs/call
632 constructor_name => "_new",
633
634 # these are Class::MOP accessors, so they need inlining
635 inline_accessors => 1
63619242µs18112ms ) for grep { $_->is_mutable }
# spent 112ms making 9 calls to Class::MOP::Class::make_immutable, avg 12.5ms/call # spent 199µs making 9 calls to Class::MOP::class_of, avg 22µs/call
637 map { Class::MOP::class_of($_) }
638 qw(
639 Moose::Meta::TypeConstraint
640 Moose::Meta::TypeConstraint::Union
641 Moose::Meta::TypeConstraint::Parameterized
642 Moose::Meta::TypeConstraint::Parameterizable
643 Moose::Meta::TypeConstraint::Class
644 Moose::Meta::TypeConstraint::Role
645 Moose::Meta::TypeConstraint::Enum
646 Moose::Meta::TypeConstraint::DuckType
647 Moose::Meta::TypeConstraint::Registry
64811µs);
649
6502136µs21.52ms
# spent 10µs within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:650] which was called # once (10µs+0s) by Moose::Meta::TypeConstraint::Bool at line 263 of Moose/Meta/TypeConstraint.pm
type 'Any' => where {1}; # meta-type including all
# spent 1.51ms making 1 call to Moose::Util::TypeConstraints::type # spent 12µs making 1 call to Moose::Util::TypeConstraints::where
651119µs21.54mssubtype 'Item' => as 'Any'; # base-type
# spent 1.53ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 10µs making 1 call to Moose::Util::TypeConstraints::as
652
653132µs31.33mssubtype 'Undef' => as 'Item' => where { !defined($_) };
# spent 1.31ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 8µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where
654132µs31.82mssubtype 'Defined' => as 'Item' => where { defined($_) };
# spent 1.80ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where
655
656subtype 'Bool' => as 'Item' =>
657252µs31.75ms
# spent 13µs within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:657] which was called # once (13µs+0s) by Moose::Meta::TypeConstraint::Bool at line 263 of Moose/Meta/TypeConstraint.pm
where { !defined($_) || $_ eq "" || "$_" eq '1' || "$_" eq '0' };
# spent 1.74ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where
658
659subtype 'Value' => as 'Defined' => where { !ref($_) } =>
660140µs4971µs optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Value;
# spent 945µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 9µs making 1 call to Moose::Util::TypeConstraints::where # spent 8µs making 1 call to Moose::Util::TypeConstraints::optimize_as
661
662subtype 'Ref' => as 'Defined' => where { ref($_) } =>
663196µs41.00ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Ref;
# spent 921µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 66µs making 1 call to Moose::Util::TypeConstraints::where # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
664
665subtype 'Str' => as 'Value' => where { ref(\$_) eq 'SCALAR' } =>
666137µs41.37ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Str;
# spent 1.35ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
667
668subtype 'Num' => as 'Str' =>
669 where { Scalar::Util::looks_like_number($_) } =>
670138µs41.08ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Num;
# spent 1.05ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
671
672subtype 'Int' => as 'Num' => where { "$_" =~ /^-?[0-9]+$/ } =>
673138µs41.07ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Int;
# spent 1.04ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 8µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
674
675subtype 'CodeRef' => as 'Ref' => where { ref($_) eq 'CODE' } =>
676194µs41.18ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::CodeRef;
# spent 1.16ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
677subtype 'RegexpRef' => as 'Ref' => where { ref($_) eq 'Regexp' } =>
678141µs42.12ms optimize_as
# spent 2.09ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::where # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
679 \&Moose::Util::TypeConstraints::OptimizedConstraints::RegexpRef;
680subtype 'GlobRef' => as 'Ref' => where { ref($_) eq 'GLOB' } =>
681139µs41.01ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::GlobRef;
# spent 988µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
682
683# NOTE:
684# scalar filehandles are GLOB refs,
685# but a GLOB ref is not always a filehandle
686subtype 'FileHandle' => as 'GlobRef' => where {
687 Scalar::Util::openhandle($_) || ( blessed($_) && $_->isa("IO::Handle") );
688139µs41.29ms} => optimize_as
# spent 1.27ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
689 \&Moose::Util::TypeConstraints::OptimizedConstraints::FileHandle;
690
691# NOTE:
692# blessed(qr/.../) returns true,.. how odd
693subtype 'Object' => as 'Ref' =>
694 where { blessed($_) && blessed($_) ne 'Regexp' } =>
695138µs4948µs optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Object;
# spent 925µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
696
697# This type is deprecated.
698subtype 'Role' => as 'Object' => where { $_->can('does') } =>
699139µs41.07ms optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Role;
# spent 1.04ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 8µs making 1 call to Moose::Util::TypeConstraints::as # spent 7µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
700
70118µsmy $_class_name_checker = sub { };
702
703subtype 'ClassName' => as 'Str' =>
704140µs41.51ms where { Class::MOP::is_class_loaded($_) } => optimize_as
# spent 1.35ms making 1 call to Moose::Util::TypeConstraints::subtype # spent 133µs making 1 call to Moose::Util::TypeConstraints::optimize_as # spent 14µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where
705 \&Moose::Util::TypeConstraints::OptimizedConstraints::ClassName;
706
707subtype 'RoleName' => as 'ClassName' => where {
708 (Class::MOP::class_of($_) || return)->isa('Moose::Meta::Role');
709187µs4958µs} => optimize_as
# spent 934µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 9µs making 1 call to Moose::Util::TypeConstraints::as # spent 8µs making 1 call to Moose::Util::TypeConstraints::where # spent 7µs making 1 call to Moose::Util::TypeConstraints::optimize_as
710 \&Moose::Util::TypeConstraints::OptimizedConstraints::RoleName;
711
712## --------------------------------------------------------
713# parameterizable types ...
714
715$REGISTRY->add_type_constraint(
716 Moose::Meta::TypeConstraint::Parameterizable->new(
717 name => 'ScalarRef',
718 package_defined_in => __PACKAGE__,
719 parent => find_type_constraint('Ref'),
720 constraint => sub { ref($_) eq 'SCALAR' || ref($_) eq 'REF' },
721 optimized =>
722 \&Moose::Util::TypeConstraints::OptimizedConstraints::ScalarRef,
723 constraint_generator => sub {
724 my $type_parameter = shift;
725 my $check = $type_parameter->_compiled_type_constraint;
726 return sub {
727 return $check->(${ $_ });
728 };
729 }
730 )
731161µs3926µs);
# spent 698µs making 1 call to Moose::Meta::TypeConstraint::new # spent 121µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 107µs making 1 call to Moose::Util::TypeConstraints::find_type_constraint
732
733$REGISTRY->add_type_constraint(
734 Moose::Meta::TypeConstraint::Parameterizable->new(
735 name => 'ArrayRef',
736 package_defined_in => __PACKAGE__,
737 parent => find_type_constraint('Ref'),
738 constraint => sub { ref($_) eq 'ARRAY' },
739 optimized =>
740 \&Moose::Util::TypeConstraints::OptimizedConstraints::ArrayRef,
741
# spent 802µs (137+665) within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:750] which was called 4 times, avg 200µs/call: # 4 times (137µs+665µs) by Moose::Meta::TypeConstraint::Parameterizable::generate_constraint_for at line 25 of Moose/Meta/TypeConstraint/Parameterizable.pm, avg 200µs/call
constraint_generator => sub {
74212172µs my $type_parameter = shift;
743 my $check = $type_parameter->_compiled_type_constraint;
# spent 665µs making 4 calls to MooseX::Types::TypeDecorator::AUTOLOAD, avg 166µs/call
744
# spent 7.27ms (4.64+2.63) within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:749] which was called 13 times, avg 559µs/call: # 13 times (4.64ms+2.63ms) by Moose::Meta::TypeConstraint::ArrayRef[Int] or Moose::Meta::TypeConstraint::ArrayRef[Str] at line 252 of Moose/Meta/TypeConstraint.pm, avg 559µs/call
return sub {
74526198µs foreach my $x (@$_) {
7462642.43ms2642.63ms ( $check->($x) ) || return;
# spent 2.63ms making 264 calls to Moose::Util::TypeConstraints::OptimizedConstraints::Str, avg 10µs/call
747 }
748 1;
749 }
750 }
751 )
7521243µs3432µs);
# spent 236µs making 1 call to Moose::Meta::TypeConstraint::new # spent 103µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 92µs making 1 call to Moose::Util::TypeConstraints::find_type_constraint
753
754$REGISTRY->add_type_constraint(
755 Moose::Meta::TypeConstraint::Parameterizable->new(
756 name => 'HashRef',
757 package_defined_in => __PACKAGE__,
758 parent => find_type_constraint('Ref'),
759 constraint => sub { ref($_) eq 'HASH' },
760 optimized =>
761 \&Moose::Util::TypeConstraints::OptimizedConstraints::HashRef,
762
# spent 143µs (41+102) within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:771] which was called # once (41µs+102µs) by Moose::Meta::TypeConstraint::Parameterizable::generate_constraint_for at line 25 of Moose/Meta/TypeConstraint/Parameterizable.pm
constraint_generator => sub {
763340µs my $type_parameter = shift;
764 my $check = $type_parameter->_compiled_type_constraint;
# spent 102µs making 1 call to MooseX::Types::TypeDecorator::AUTOLOAD
765
# spent 102µs within Moose::Util::TypeConstraints::__ANON__[/usr/lib/perl5/vendor_perl/5.10.1/i386-linux-thread-multi/Moose/Util/TypeConstraints.pm:770] which was called 8 times, avg 13µs/call: # 8 times (102µs+0s) by Moose::Meta::TypeConstraint::HashRef[ArrayRef[Str]] at line 252 of Moose/Meta/TypeConstraint.pm, avg 13µs/call
return sub {
76616123µs foreach my $x ( values %$_ ) {
767 ( $check->($x) ) || return;
768 }
769 1;
770 }
771 }
772 )
773137µs3491µs);
# spent 298µs making 1 call to Moose::Meta::TypeConstraint::new # spent 103µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 90µs making 1 call to Moose::Util::TypeConstraints::find_type_constraint
774
775$REGISTRY->add_type_constraint(
776 Moose::Meta::TypeConstraint::Parameterizable->new(
777 name => 'Maybe',
778 package_defined_in => __PACKAGE__,
779 parent => find_type_constraint('Item'),
780 constraint => sub {1},
781 constraint_generator => sub {
782 my $type_parameter = shift;
783 my $check = $type_parameter->_compiled_type_constraint;
784 return sub {
785 return 1 if not( defined($_) ) || $check->($_);
786 return;
787 }
788 }
789 )
790134µs3877µs);
# spent 620µs making 1 call to Moose::Meta::TypeConstraint::new # spent 166µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 91µs making 1 call to Moose::Util::TypeConstraints::find_type_constraint
791
792my @PARAMETERIZABLE_TYPES
7935172µs4106µs = map { $REGISTRY->get_type_constraint($_) } qw[ScalarRef ArrayRef HashRef Maybe];
# spent 106µs making 4 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 26µs/call
794
7955170µs
# spent 148µs within Moose::Util::TypeConstraints::get_all_parameterizable_types which was called 5 times, avg 30µs/call: # 5 times (148µs+0s) by Moose::Meta::TypeConstraint::Parameterized::compile_type_constraint at line 51 of Moose/Meta/TypeConstraint/Parameterized.pm, avg 30µs/call
sub get_all_parameterizable_types {@PARAMETERIZABLE_TYPES}
796
797sub add_parameterizable_type {
798 my $type = shift;
799 ( blessed $type
800 && $type->isa('Moose::Meta::TypeConstraint::Parameterizable') )
801 || __PACKAGE__->_throw_error(
802 "Type must be a Moose::Meta::TypeConstraint::Parameterizable not $type"
803 );
804 push @PARAMETERIZABLE_TYPES => $type;
805}
806
807## --------------------------------------------------------
808# end of built-in types ...
809## --------------------------------------------------------
810
811{
812268µs142µs my @BUILTINS = list_all_type_constraints();
# spent 42µs making 1 call to Moose::Util::TypeConstraints::list_all_type_constraints
813132µs
# spent 23µs within Moose::Util::TypeConstraints::list_all_builtin_type_constraints which was called # once (23µs+0s) by MooseX::Role::WithOverloading::Meta::Role::Application::BEGIN@7 at line 52 of MooseX/Types/Moose.pm
sub list_all_builtin_type_constraints {@BUILTINS}
814}
815
816sub _throw_error {
817 shift;
818 require Moose;
819 unshift @_, 'Moose';
820 goto &Moose::throw_error;
821}
822
8231325µs1;
824
825__END__
826
827=pod
828
829=head1 NAME
830
831Moose::Util::TypeConstraints - Type constraint system for Moose
832
833=head1 SYNOPSIS
834
835 use Moose::Util::TypeConstraints;
836
837 subtype 'Natural'
838 => as 'Int'
839 => where { $_ > 0 };
840
841 subtype 'NaturalLessThanTen'
842 => as 'Natural'
843 => where { $_ < 10 }
844 => message { "This number ($_) is not less than ten!" };
845
846 coerce 'Num'
847 => from 'Str'
848 => via { 0+$_ };
849
850 enum 'RGBColors' => qw(red green blue);
851
852 no Moose::Util::TypeConstraints;
853
854=head1 DESCRIPTION
855
856This module provides Moose with the ability to create custom type
857constraints to be used in attribute definition.
858
859=head2 Important Caveat
860
861This is B<NOT> a type system for Perl 5. These are type constraints,
862and they are not used by Moose unless you tell it to. No type
863inference is performed, expressions are not typed, etc. etc. etc.
864
865A type constraint is at heart a small "check if a value is valid"
866function. A constraint can be associated with an attribute. This
867simplifies parameter validation, and makes your code clearer to read,
868because you can refer to constraints by name.
869
870=head2 Slightly Less Important Caveat
871
872It is B<always> a good idea to quote your type names.
873
874This prevents Perl from trying to execute the call as an indirect
875object call. This can be an issue when you have a subtype with the
876same name as a valid class.
877
878For instance:
879
880 subtype DateTime => as Object => where { $_->isa('DateTime') };
881
882will I<just work>, while this:
883
884 use DateTime;
885 subtype DateTime => as Object => where { $_->isa('DateTime') };
886
887will fail silently and cause many headaches. The simple way to solve
888this, as well as future proof your subtypes from classes which have
889yet to have been created, is to quote the type name:
890
891 use DateTime;
892 subtype 'DateTime' => as 'Object' => where { $_->isa('DateTime') };
893
894=head2 Default Type Constraints
895
896This module also provides a simple hierarchy for Perl 5 types, here is
897that hierarchy represented visually.
898
899 Any
900 Item
901 Bool
902 Maybe[`a]
903 Undef
904 Defined
905 Value
906 Str
907 Num
908 Int
909 ClassName
910 RoleName
911 Ref
912 ScalarRef[`a]
913 ArrayRef[`a]
914 HashRef[`a]
915 CodeRef
916 RegexpRef
917 GlobRef
918 FileHandle
919 Object
920
921B<NOTE:> Any type followed by a type parameter C<[`a]> can be
922parameterized, this means you can say:
923
924 ArrayRef[Int] # an array of integers
925 HashRef[CodeRef] # a hash of str to CODE ref mappings
926 ScalarRef[Int] # a reference to an integer
927 Maybe[Str] # value may be a string, may be undefined
928
929If Moose finds a name in brackets that it does not recognize as an
930existing type, it assumes that this is a class name, for example
931C<ArrayRef[DateTime]>.
932
933B<NOTE:> Unless you parameterize a type, then it is invalid to include
934the square brackets. I.e. C<ArrayRef[]> will be treated as a new type
935name, I<not> as a parameterization of C<ArrayRef>.
936
937B<NOTE:> The C<Undef> type constraint for the most part works
938correctly now, but edge cases may still exist, please use it
939sparingly.
940
941B<NOTE:> The C<ClassName> type constraint does a complex package
942existence check. This means that your class B<must> be loaded for this
943type constraint to pass.
944
945B<NOTE:> The C<RoleName> constraint checks a string is a I<package
946name> which is a role, like C<'MyApp::Role::Comparable'>.
947
948=head2 Type Constraint Naming
949
950Type name declared via this module can only contain alphanumeric
951characters, colons (:), and periods (.).
952
953Since the types created by this module are global, it is suggested
954that you namespace your types just as you would namespace your
955modules. So instead of creating a I<Color> type for your
956B<My::Graphics> module, you would call the type
957I<My::Graphics::Types::Color> instead.
958
959=head2 Use with Other Constraint Modules
960
961This module can play nicely with other constraint modules with some
962slight tweaking. The C<where> clause in types is expected to be a
963C<CODE> reference which checks it's first argument and returns a
964boolean. Since most constraint modules work in a similar way, it
965should be simple to adapt them to work with Moose.
966
967For instance, this is how you could use it with
968L<Declare::Constraints::Simple> to declare a completely new type.
969
970 type 'HashOfArrayOfObjects',
971 {
972 where => IsHashRef(
973 -keys => HasLength,
974 -values => IsArrayRef(IsObject)
975 )
976 };
977
978For more examples see the F<t/200_examples/004_example_w_DCS.t> test
979file.
980
981Here is an example of using L<Test::Deep> and it's non-test
982related C<eq_deeply> function.
983
984 type 'ArrayOfHashOfBarsAndRandomNumbers'
985 => where {
986 eq_deeply($_,
987 array_each(subhashof({
988 bar => isa('Bar'),
989 random_number => ignore()
990 })))
991 };
992
993For a complete example see the
994F<t/200_examples/005_example_w_TestDeep.t> test file.
995
996=head1 FUNCTIONS
997
998=head2 Type Constraint Constructors
999
1000The following functions are used to create type constraints. They
1001will also register the type constraints your create in a global
1002registry that is used to look types up by name.
1003
1004See the L</SYNOPSIS> for an example of how to use these.
1005
1006=over 4
1007
1008=item B<< subtype 'Name' => as 'Parent' => where { } ... >>
1009
1010This creates a named subtype.
1011
1012If you provide a parent that Moose does not recognize, it will
1013automatically create a new class type constraint for this name.
1014
1015When creating a named type, the C<subtype> function should either be
1016called with the sugar helpers (C<where>, C<message>, etc), or with a
1017name and a hashref of parameters:
1018
1019 subtype( 'Foo', { where => ..., message => ... } );
1020
1021The valid hashref keys are C<as> (the parent), C<where>, C<message>,
1022and C<optimize_as>.
1023
1024=item B<< subtype as 'Parent' => where { } ... >>
1025
1026This creates an unnamed subtype and will return the type
1027constraint meta-object, which will be an instance of
1028L<Moose::Meta::TypeConstraint>.
1029
1030When creating an anonymous type, the C<subtype> function should either
1031be called with the sugar helpers (C<where>, C<message>, etc), or with
1032just a hashref of parameters:
1033
1034 subtype( { where => ..., message => ... } );
1035
1036=item B<class_type ($class, ?$options)>
1037
1038Creates a new subtype of C<Object> with the name C<$class> and the
1039metaclass L<Moose::Meta::TypeConstraint::Class>.
1040
1041=item B<role_type ($role, ?$options)>
1042
1043Creates a C<Role> type constraint with the name C<$role> and the
1044metaclass L<Moose::Meta::TypeConstraint::Role>.
1045
1046=item B<maybe_type ($type)>
1047
1048Creates a type constraint for either C<undef> or something of the
1049given type.
1050
1051=item B<duck_type ($name, \@methods)>
1052
1053This will create a subtype of Object and test to make sure the value
1054C<can()> do the methods in C<\@methods>.
1055
1056This is intended as an easy way to accept non-Moose objects that
1057provide a certain interface. If you're using Moose classes, we
1058recommend that you use a C<requires>-only Role instead.
1059
1060=item B<duck_type (\@methods)>
1061
1062If passed an ARRAY reference as the only parameter instead of the
1063C<$name>, C<\@methods> pair, this will create an unnamed duck type.
1064This can be used in an attribute definition like so:
1065
1066 has 'cache' => (
1067 is => 'ro',
1068 isa => duck_type( [qw( get_set )] ),
1069 );
1070
1071=item B<enum ($name, \@values)>
1072
1073This will create a basic subtype for a given set of strings.
1074The resulting constraint will be a subtype of C<Str> and
1075will match any of the items in C<\@values>. It is case sensitive.
1076See the L</SYNOPSIS> for a simple example.
1077
1078B<NOTE:> This is not a true proper enum type, it is simply
1079a convenient constraint builder.
1080
1081=item B<enum (\@values)>
1082
1083If passed an ARRAY reference as the only parameter instead of the
1084C<$name>, C<\@values> pair, this will create an unnamed enum. This
1085can then be used in an attribute definition like so:
1086
1087 has 'sort_order' => (
1088 is => 'ro',
1089 isa => enum([qw[ ascending descending ]]),
1090 );
1091
1092=item B<as 'Parent'>
1093
1094This is just sugar for the type constraint construction syntax.
1095
1096It takes a single argument, which is the name of a parent type.
1097
1098=item B<where { ... }>
1099
1100This is just sugar for the type constraint construction syntax.
1101
1102It takes a subroutine reference as an argument. When the type
1103constraint is tested, the reference is run with the value to be tested
1104in C<$_>. This reference should return true or false to indicate
1105whether or not the constraint check passed.
1106
1107=item B<message { ... }>
1108
1109This is just sugar for the type constraint construction syntax.
1110
1111It takes a subroutine reference as an argument. When the type
1112constraint fails, then the code block is run with the value provided
1113in C<$_>. This reference should return a string, which will be used in
1114the text of the exception thrown.
1115
1116=item B<optimize_as { ... }>
1117
1118This can be used to define a "hand optimized" version of your
1119type constraint which can be used to avoid traversing a subtype
1120constraint hierarchy.
1121
1122B<NOTE:> You should only use this if you know what you are doing,
1123all the built in types use this, so your subtypes (assuming they
1124are shallow) will not likely need to use this.
1125
1126=item B<< type 'Name' => where { } ... >>
1127
1128This creates a base type, which has no parent.
1129
1130The C<type> function should either be called with the sugar helpers
1131(C<where>, C<message>, etc), or with a name and a hashref of
1132parameters:
1133
1134 type( 'Foo', { where => ..., message => ... } );
1135
1136The valid hashref keys are C<where>, C<message>, and C<optimize_as>.
1137
1138=back
1139
1140=head2 Type Constraint Utilities
1141
1142=over 4
1143
1144=item B<< match_on_type $value => ( $type => \&action, ... ?\&default ) >>
1145
1146This is a utility function for doing simple type based dispatching similar to
1147match/case in OCaml and case/of in Haskell. It is not as featureful as those
1148languages, nor does not it support any kind of automatic destructuring
1149bind. Here is a simple Perl pretty printer dispatching over the core Moose
1150types.
1151
1152 sub ppprint {
1153 my $x = shift;
1154 match_on_type $x => (
1155 HashRef => sub {
1156 my $hash = shift;
1157 '{ '
1158 . (
1159 join ", " => map { $_ . ' => ' . ppprint( $hash->{$_} ) }
1160 sort keys %$hash
1161 ) . ' }';
1162 },
1163 ArrayRef => sub {
1164 my $array = shift;
1165 '[ ' . ( join ", " => map { ppprint($_) } @$array ) . ' ]';
1166 },
1167 CodeRef => sub {'sub { ... }'},
1168 RegexpRef => sub { 'qr/' . $_ . '/' },
1169 GlobRef => sub { '*' . B::svref_2object($_)->NAME },
1170 Object => sub { $_->can('to_string') ? $_->to_string : $_ },
1171 ScalarRef => sub { '\\' . ppprint( ${$_} ) },
1172 Num => sub {$_},
1173 Str => sub { '"' . $_ . '"' },
1174 Undef => sub {'undef'},
1175 => sub { die "I don't know what $_ is" }
1176 );
1177 }
1178
1179Or a simple JSON serializer:
1180
1181 sub to_json {
1182 my $x = shift;
1183 match_on_type $x => (
1184 HashRef => sub {
1185 my $hash = shift;
1186 '{ '
1187 . (
1188 join ", " =>
1189 map { '"' . $_ . '" : ' . to_json( $hash->{$_} ) }
1190 sort keys %$hash
1191 ) . ' }';
1192 },
1193 ArrayRef => sub {
1194 my $array = shift;
1195 '[ ' . ( join ", " => map { to_json($_) } @$array ) . ' ]';
1196 },
1197 Num => sub {$_},
1198 Str => sub { '"' . $_ . '"' },
1199 Undef => sub {'null'},
1200 => sub { die "$_ is not acceptable json type" }
1201 );
1202 }
1203
1204The matcher is done by mapping a C<$type> to an C<\&action>. The C<$type> can
1205be either a string type or a L<Moose::Meta::TypeConstraint> object, and
1206C<\&action> is a subroutine reference. This function will dispatch on the
1207first match for C<$value>. It is possible to have a catch-all by providing an
1208additional subroutine reference as the final argument to C<match_on_type>.
1209
1210=back
1211
1212=head2 Type Coercion Constructors
1213
1214You can define coercions for type constraints, which allow you to
1215automatically transform values to something valid for the type
1216constraint. If you ask your accessor to coerce, then Moose will run
1217the type-coercion code first, followed by the type constraint
1218check. This feature should be used carefully as it is very powerful
1219and could easily take off a limb if you are not careful.
1220
1221See the L</SYNOPSIS> for an example of how to use these.
1222
1223=over 4
1224
1225=item B<< coerce 'Name' => from 'OtherName' => via { ... } >>
1226
1227This defines a coercion from one type to another. The C<Name> argument
1228is the type you are coercing I<to>.
1229
1230=item B<from 'OtherName'>
1231
1232This is just sugar for the type coercion construction syntax.
1233
1234It takes a single type name (or type object), which is the type being
1235coerced I<from>.
1236
1237=item B<via { ... }>
1238
1239This is just sugar for the type coercion construction syntax.
1240
1241It takes a subroutine reference. This reference will be called with
1242the value to be coerced in C<$_>. It is expected to return a new value
1243of the proper type for the coercion.
1244
1245=back
1246
1247=head2 Creating and Finding Type Constraints
1248
1249These are additional functions for creating and finding type
1250constraints. Most of these functions are not available for
1251importing. The ones that are importable as specified.
1252
1253=over 4
1254
1255=item B<find_type_constraint($type_name)>
1256
1257This function can be used to locate the L<Moose::Meta::TypeConstraint>
1258object for a named type.
1259
1260This function is importable.
1261
1262=item B<register_type_constraint($type_object)>
1263
1264This function will register a L<Moose::Meta::TypeConstraint> with the
1265global type registry.
1266
1267This function is importable.
1268
1269=item B<normalize_type_constraint_name($type_constraint_name)>
1270
1271This method takes a type constraint name and returns the normalized
1272form. This removes any whitespace in the string.
1273
1274=item B<create_type_constraint_union($pipe_separated_types | @type_constraint_names)>
1275
1276This can take a union type specification like C<'Int|ArrayRef[Int]'>,
1277or a list of names. It returns a new
1278L<Moose::Meta::TypeConstraint::Union> object.
1279
1280=item B<create_parameterized_type_constraint($type_name)>
1281
1282Given a C<$type_name> in the form of C<'BaseType[ContainerType]'>,
1283this will create a new L<Moose::Meta::TypeConstraint::Parameterized>
1284object. The C<BaseType> must exist already exist as a parameterizable
1285type.
1286
1287=item B<create_class_type_constraint($class, $options)>
1288
1289Given a class name this function will create a new
1290L<Moose::Meta::TypeConstraint::Class> object for that class name.
1291
1292The C<$options> is a hash reference that will be passed to the
1293L<Moose::Meta::TypeConstraint::Class> constructor (as a hash).
1294
1295=item B<create_role_type_constraint($role, $options)>
1296
1297Given a role name this function will create a new
1298L<Moose::Meta::TypeConstraint::Role> object for that role name.
1299
1300The C<$options> is a hash reference that will be passed to the
1301L<Moose::Meta::TypeConstraint::Role> constructor (as a hash).
1302
1303=item B<create_enum_type_constraint($name, $values)>
1304
1305Given a enum name this function will create a new
1306L<Moose::Meta::TypeConstraint::Enum> object for that enum name.
1307
1308=item B<create_duck_type_constraint($name, $methods)>
1309
1310Given a duck type name this function will create a new
1311L<Moose::Meta::TypeConstraint::DuckType> object for that enum name.
1312
1313=item B<find_or_parse_type_constraint($type_name)>
1314
1315Given a type name, this first attempts to find a matching constraint
1316in the global registry.
1317
1318If the type name is a union or parameterized type, it will create a
1319new object of the appropriate, but if given a "regular" type that does
1320not yet exist, it simply returns false.
1321
1322When given a union or parameterized type, the member or base type must
1323already exist.
1324
1325If it creates a new union or parameterized type, it will add it to the
1326global registry.
1327
1328=item B<find_or_create_isa_type_constraint($type_name)>
1329
1330=item B<find_or_create_does_type_constraint($type_name)>
1331
1332These functions will first call C<find_or_parse_type_constraint>. If
1333that function does not return a type, a new anonymous type object will
1334be created.
1335
1336The C<isa> variant will use C<create_class_type_constraint> and the
1337C<does> variant will use C<create_role_type_constraint>.
1338
1339=item B<get_type_constraint_registry>
1340
1341Returns the L<Moose::Meta::TypeConstraint::Registry> object which
1342keeps track of all type constraints.
1343
1344=item B<list_all_type_constraints>
1345
1346This will return a list of type constraint names in the global
1347registry. You can then fetch the actual type object using
1348C<find_type_constraint($type_name)>.
1349
1350=item B<list_all_builtin_type_constraints>
1351
1352This will return a list of builtin type constraints, meaning those
1353which are defined in this module. See the L<Default Type Constraints>
1354section for a complete list.
1355
1356=item B<export_type_constraints_as_functions>
1357
1358This will export all the current type constraints as functions into
1359the caller's namespace (C<Int()>, C<Str()>, etc). Right now, this is
1360mostly used for testing, but it might prove useful to others.
1361
1362=item B<get_all_parameterizable_types>
1363
1364This returns all the parameterizable types that have been registered,
1365as a list of type objects.
1366
1367=item B<add_parameterizable_type($type)>
1368
1369Adds C<$type> to the list of parameterizable types
1370
1371=back
1372
1373=head1 BUGS
1374
1375See L<Moose/BUGS> for details on reporting bugs.
1376
1377=head1 AUTHOR
1378
1379Stevan Little E<lt>stevan@iinteractive.comE<gt>
1380
1381=head1 COPYRIGHT AND LICENSE
1382
1383Copyright 2006-2010 by Infinity Interactive, Inc.
1384
1385L<http://www.iinteractive.com>
1386
1387This library is free software; you can redistribute it and/or modify
1388it under the same terms as Perl itself.
1389
1390=cut
# spent 190µs within Moose::Util::TypeConstraints::CORE:match which was called 20 times, avg 9µs/call: # 18 times (186µs+0s) by Moose::Util::TypeConstraints::_create_type_constraint at line 508 of Moose/Util/TypeConstraints.pm, avg 10µs/call # once (2µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 620 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 599 of Moose/Util/TypeConstraints.pm
sub Moose::Util::TypeConstraints::CORE:match; # xsub
# spent 98µs within Moose::Util::TypeConstraints::CORE:qr which was called 9 times, avg 11µs/call: # once (42µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 576 of Moose/Util/TypeConstraints.pm # once (15µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 574 of Moose/Util/TypeConstraints.pm # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 580 of Moose/Util/TypeConstraints.pm # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 589 of Moose/Util/TypeConstraints.pm # once (6µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 581 of Moose/Util/TypeConstraints.pm # once (6µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 583 of Moose/Util/TypeConstraints.pm # once (6µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 587 of Moose/Util/TypeConstraints.pm # once (5µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 586 of Moose/Util/TypeConstraints.pm # once (5µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 575 of Moose/Util/TypeConstraints.pm
sub Moose::Util::TypeConstraints::CORE:qr; # xsub
# spent 1.49ms within Moose::Util::TypeConstraints::CORE:regcomp which was called 9 times, avg 165µs/call: # once (305µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 580 of Moose/Util/TypeConstraints.pm # once (300µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 589 of Moose/Util/TypeConstraints.pm # once (296µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 581 of Moose/Util/TypeConstraints.pm # once (193µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 587 of Moose/Util/TypeConstraints.pm # once (151µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 583 of Moose/Util/TypeConstraints.pm # once (124µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 620 of Moose/Util/TypeConstraints.pm # once (48µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 575 of Moose/Util/TypeConstraints.pm # once (42µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 599 of Moose/Util/TypeConstraints.pm # once (30µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 586 of Moose/Util/TypeConstraints.pm
sub Moose::Util::TypeConstraints::CORE:regcomp; # xsub
# spent 772µs (268+504) within Moose::Util::TypeConstraints::CORE:subst which was called 43 times, avg 18µs/call: # 43 times (268µs+504µs) by Moose::Util::TypeConstraints::normalize_type_constraint_name at line 237 of Moose/Util/TypeConstraints.pm, avg 18µs/call
sub Moose::Util::TypeConstraints::CORE:subst; # xsub
Report produced by the NYTProf 3.11 Perl profiler, developed by Tim Bunce and Adam Kaplan.