Profile of /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For 05.Domain_and_Item.t
Run on Tue May 4 17:21:41 2010
Reported on Tue May 4 17:22:20 2010

File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm
Statements Executed | 4670
Statement Execution Time | 14.6ms

Subroutines — ordered by exclusive time
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
510 | 17 | 9 | 3.72ms | 8.86ms | Moose::Util::TypeConstraints::::find_type_constraintMoose::Util::TypeConstraints::find_type_constraint
1 | 1 | 1 | 860µs | 912µs | Moose::Util::TypeConstraints::::BEGIN@572Moose::Util::TypeConstraints::BEGIN@572
95 | 3 | 1 | 860µs | 7.73ms | Moose::Util::TypeConstraints::::find_or_parse_type_constraintMoose::Util::TypeConstraints::find_or_parse_type_constraint
154 | 1 | 1 | 717µs | 1.95ms | Moose::Util::TypeConstraints::::__ANON__[:749]Moose::Util::TypeConstraints::__ANON__[:749]
1 | 1 | 1 | 688µs | 1.84ms | Moose::Util::TypeConstraints::::BEGIN@29Moose::Util::TypeConstraints::BEGIN@29
29 | 2 | 1 | 678µs | 7.39ms | Moose::Util::TypeConstraints::::_create_type_constraintMoose::Util::TypeConstraints::_create_type_constraint
1 | 1 | 1 | 631µs | 1.34ms | Moose::Util::TypeConstraints::::BEGIN@35Moose::Util::TypeConstraints::BEGIN@35
28 | 19 | 3 | 608µs | 7.92ms | Moose::Util::TypeConstraints::::subtypeMoose::Util::TypeConstraints::subtype
1 | 1 | 1 | 606µs | 1.11ms | Moose::Util::TypeConstraints::::BEGIN@32Moose::Util::TypeConstraints::BEGIN@32
1 | 1 | 1 | 543µs | 1.05ms | Moose::Util::TypeConstraints::::BEGIN@33Moose::Util::TypeConstraints::BEGIN@33
87 | 3 | 3 | 525µs | 7.37ms | Moose::Util::TypeConstraints::::find_or_create_isa_type_constraintMoose::Util::TypeConstraints::find_or_create_isa_type_constraint
1 | 1 | 1 | 523µs | 597µs | Moose::Util::TypeConstraints::::BEGIN@39Moose::Util::TypeConstraints::BEGIN@39
1 | 1 | 1 | 481µs | 980µs | Moose::Util::TypeConstraints::::BEGIN@34Moose::Util::TypeConstraints::BEGIN@34
1 | 1 | 1 | 455µs | 2.22ms | Moose::Util::TypeConstraints::::BEGIN@30Moose::Util::TypeConstraints::BEGIN@30
23 | 12 | 2 | 452µs | 452µs | Moose::Util::TypeConstraints::::CORE:regcompMoose::Util::TypeConstraints::CORE:regcomp (opcode)
1 | 1 | 1 | 442µs | 1.54ms | Moose::Util::TypeConstraints::::BEGIN@38Moose::Util::TypeConstraints::BEGIN@38
49 | 2 | 1 | 400µs | 1.65ms | Moose::Util::TypeConstraints::::register_type_constraintMoose::Util::TypeConstraints::register_type_constraint
28 | 2 | 1 | 352µs | 3.75ms | Moose::Util::TypeConstraints::::create_class_type_constraintMoose::Util::TypeConstraints::create_class_type_constraint
95 | 1 | 1 | 330µs | 474µs | Moose::Util::TypeConstraints::::normalize_type_constraint_nameMoose::Util::TypeConstraints::normalize_type_constraint_name
22 | 1 | 1 | 197µs | 2.13ms | Moose::Util::TypeConstraints::::create_role_type_constraintMoose::Util::TypeConstraints::create_role_type_constraint
27 | 2 | 2 | 186µs | 4.76ms | Moose::Util::TypeConstraints::::class_typeMoose::Util::TypeConstraints::class_type
45 | 6 | 2 | 159µs | 281µs | Moose::Util::TypeConstraints::::CORE:matchMoose::Util::TypeConstraints::CORE:match (opcode)
10 | 1 | 1 | 130µs | 3.33ms | Moose::Util::TypeConstraints::::_install_type_coercionsMoose::Util::TypeConstraints::_install_type_coercions
22 | 1 | 1 | 116µs | 2.94ms | Moose::Util::TypeConstraints::::role_typeMoose::Util::TypeConstraints::role_type
95 | 1 | 2 | 93µs | 144µs | Moose::Util::TypeConstraints::::CORE:substMoose::Util::TypeConstraints::CORE:subst (opcode)
3 | 1 | 1 | 67µs | 3.11ms | Moose::Util::TypeConstraints::::create_parameterized_type_constraintMoose::Util::TypeConstraints::create_parameterized_type_constraint
28 | 19 | 3 | 53µs | 53µs | Moose::Util::TypeConstraints::::asMoose::Util::TypeConstraints::as
5 | 1 | 1 | 48µs | 133µs | Moose::Util::TypeConstraints::::__ANON__[:750]Moose::Util::TypeConstraints::__ANON__[:750]
6 | 2 | 2 | 45µs | 1.46ms | Moose::Util::TypeConstraints::::find_or_create_type_constraintMoose::Util::TypeConstraints::find_or_create_type_constraint
10 | 1 | 1 | 44µs | 44µs | Moose::Util::TypeConstraints::::__ANON__[:657]Moose::Util::TypeConstraints::__ANON__[:657]
6 | 2 | 1 | 44µs | 152µs | Moose::Util::TypeConstraints::::_detect_type_constraint_unionMoose::Util::TypeConstraints::_detect_type_constraint_union
3 | 1 | 1 | 42µs | 2.93ms | Moose::Util::TypeConstraints::::_create_parameterized_type_constraintMoose::Util::TypeConstraints::_create_parameterized_type_constraint
15 | 1 | 1 | 41µs | 41µs | Moose::Util::TypeConstraints::::__ANON__[:650]Moose::Util::TypeConstraints::__ANON__[:650]
1 | 1 | 1 | 40µs | 1.70ms | Moose::Util::TypeConstraints::::create_type_constraint_unionMoose::Util::TypeConstraints::create_type_constraint_union
10 | 1 | 1 | 37µs | 3.37ms | Moose::Util::TypeConstraints::::coerceMoose::Util::TypeConstraints::coerce
21 | 21 | 2 | 34µs | 34µs | Moose::Util::TypeConstraints::::whereMoose::Util::TypeConstraints::where
3 | 1 | 1 | 34µs | 79µs | Moose::Util::TypeConstraints::::_parse_parameterized_type_constraintMoose::Util::TypeConstraints::_parse_parameterized_type_constraint
30 | 1 | 1 | 32µs | 32µs | Moose::Util::TypeConstraints::::fromMoose::Util::TypeConstraints::from
30 | 11 | 1 | 31µs | 31µs | Moose::Util::TypeConstraints::::viaMoose::Util::TypeConstraints::via
4 | 1 | 1 | 31µs | 91µs | Moose::Util::TypeConstraints::::_detect_parameterized_type_constraintMoose::Util::TypeConstraints::_detect_parameterized_type_constraint
1 | 1 | 1 | 28µs | 92µs | Moose::Util::TypeConstraints::::_parse_type_constraint_unionMoose::Util::TypeConstraints::_parse_type_constraint_union
1 | 1 | 1 | 21µs | 279µs | Moose::Util::TypeConstraints::::typeMoose::Util::TypeConstraints::type
5 | 1 | 1 | 20µs | 20µs | Moose::Util::TypeConstraints::::__ANON__[:653]Moose::Util::TypeConstraints::__ANON__[:653]
2 | 1 | 1 | 19µs | 22µs | Moose::Util::TypeConstraints::::__ANON__[:771]Moose::Util::TypeConstraints::__ANON__[:771]
7 | 1 | 1 | 17µs | 17µs | Moose::Util::TypeConstraints::::get_all_parameterizable_typesMoose::Util::TypeConstraints::get_all_parameterizable_types
13 | 13 | 1 | 16µs | 16µs | Moose::Util::TypeConstraints::::optimize_asMoose::Util::TypeConstraints::optimize_as
9 | 9 | 2 | 15µs | 15µs | Moose::Util::TypeConstraints::::CORE:qrMoose::Util::TypeConstraints::CORE:qr (opcode)
1 | 1 | 1 | 13µs | 14µs | Moose::Util::TypeConstraints::::list_all_type_constraintsMoose::Util::TypeConstraints::list_all_type_constraints
2 | 1 | 1 | 10µs | 10µs | Moose::Util::TypeConstraints::::__ANON__[:770]Moose::Util::TypeConstraints::__ANON__[:770]
1 | 1 | 1 | 10µs | 27µs | Moose::Util::TypeConstraints::::BEGIN@592Moose::Util::TypeConstraints::BEGIN@592
1 | 1 | 1 | 10µs | 18µs | Moose::Util::TypeConstraints::::BEGIN@598Moose::Util::TypeConstraints::BEGIN@598
1 | 1 | 1 | 10µs | 10µs | Moose::Util::TypeConstraints::::BEGIN@4Moose::Util::TypeConstraints::BEGIN@4
1 | 1 | 1 | 9µs | 9µs | Moose::Util::TypeConstraints::::list_all_builtin_type_constraintsMoose::Util::TypeConstraints::list_all_builtin_type_constraints
1 | 1 | 1 | 8µs | 17µs | Moose::Util::TypeConstraints::::BEGIN@619Moose::Util::TypeConstraints::BEGIN@619
1 | 1 | 1 | 8µs | 16µs | Moose::Util::TypeConstraints::::BEGIN@603Moose::Util::TypeConstraints::BEGIN@603
1 | 1 | 1 | 8µs | 24µs | Moose::Util::TypeConstraints::::BEGIN@65Moose::Util::TypeConstraints::BEGIN@65
1 | 1 | 1 | 7µs | 25µs | Moose::Util::TypeConstraints::::BEGIN@7Moose::Util::TypeConstraints::BEGIN@7
1 | 1 | 1 | 7µs | 7µs | Moose::Util::TypeConstraints::::BEGIN@36Moose::Util::TypeConstraints::BEGIN@36
1 | 1 | 1 | 6µs | 32µs | Moose::Util::TypeConstraints::::BEGIN@6Moose::Util::TypeConstraints::BEGIN@6
1 | 1 | 1 | 6µs | 35µs | Moose::Util::TypeConstraints::::BEGIN@5Moose::Util::TypeConstraints::BEGIN@5
1 | 1 | 1 | 4µs | 4µs | Moose::Util::TypeConstraints::::BEGIN@31Moose::Util::TypeConstraints::BEGIN@31
1 | 1 | 1 | 4µs | 4µs | Moose::Util::TypeConstraints::::BEGIN@28Moose::Util::TypeConstraints::BEGIN@28
1 | 1 | 1 | 3µs | 3µs | Moose::Util::TypeConstraints::::BEGIN@37Moose::Util::TypeConstraints::BEGIN@37
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:277]Moose::Util::TypeConstraints::__ANON__[:277]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:302]Moose::Util::TypeConstraints::__ANON__[:302]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:308]Moose::Util::TypeConstraints::__ANON__[:308]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:654]Moose::Util::TypeConstraints::__ANON__[:654]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:659]Moose::Util::TypeConstraints::__ANON__[:659]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:662]Moose::Util::TypeConstraints::__ANON__[:662]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:665]Moose::Util::TypeConstraints::__ANON__[:665]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:669]Moose::Util::TypeConstraints::__ANON__[:669]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:672]Moose::Util::TypeConstraints::__ANON__[:672]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:675]Moose::Util::TypeConstraints::__ANON__[:675]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:677]Moose::Util::TypeConstraints::__ANON__[:677]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:680]Moose::Util::TypeConstraints::__ANON__[:680]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:688]Moose::Util::TypeConstraints::__ANON__[:688]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:694]Moose::Util::TypeConstraints::__ANON__[:694]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:698]Moose::Util::TypeConstraints::__ANON__[:698]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:701]Moose::Util::TypeConstraints::__ANON__[:701]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:704]Moose::Util::TypeConstraints::__ANON__[:704]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:709]Moose::Util::TypeConstraints::__ANON__[:709]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:70]Moose::Util::TypeConstraints::__ANON__[:70]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:720]Moose::Util::TypeConstraints::__ANON__[:720]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:728]Moose::Util::TypeConstraints::__ANON__[:728]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:729]Moose::Util::TypeConstraints::__ANON__[:729]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:738]Moose::Util::TypeConstraints::__ANON__[:738]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:759]Moose::Util::TypeConstraints::__ANON__[:759]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:780]Moose::Util::TypeConstraints::__ANON__[:780]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:787]Moose::Util::TypeConstraints::__ANON__[:787]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::__ANON__[:788]Moose::Util::TypeConstraints::__ANON__[:788]
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::_confessMoose::Util::TypeConstraints::_confess
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::_throw_errorMoose::Util::TypeConstraints::_throw_error
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::add_parameterizable_typeMoose::Util::TypeConstraints::add_parameterizable_type
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::create_duck_type_constraintMoose::Util::TypeConstraints::create_duck_type_constraint
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::create_enum_type_constraintMoose::Util::TypeConstraints::create_enum_type_constraint
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::duck_typeMoose::Util::TypeConstraints::duck_type
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::enumMoose::Util::TypeConstraints::enum
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::export_type_constraints_as_functionsMoose::Util::TypeConstraints::export_type_constraints_as_functions
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::find_or_create_does_type_constraintMoose::Util::TypeConstraints::find_or_create_does_type_constraint
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::get_type_constraint_registryMoose::Util::TypeConstraints::get_type_constraint_registry
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::match_on_typeMoose::Util::TypeConstraints::match_on_type
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::maybe_typeMoose::Util::TypeConstraints::maybe_type
0 | 0 | 0 | 0s | 0s | Moose::Util::TypeConstraints::::messageMoose::Util::TypeConstraints::message

Call graph for these subroutines as a Graphviz dot language file.

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  |
2 |  |  |  |  | package Moose::Util::TypeConstraints;
3 |  |  |  |  |
4 | 3 | 23µs | 1 | 10µs | # spent 10µs within Moose::Util::TypeConstraints::BEGIN@4 which was called # once (10µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 4 use Carp (); # spent 10µs making 1 call to Moose::Util::TypeConstraints::BEGIN@4
5 | 3 | 24µs | 2 | 64µs | # spent 35µs (6+29) within Moose::Util::TypeConstraints::BEGIN@5 which was called # once (6µs+29µs) by Moose::Meta::Attribute::BEGIN@18 at line 5 use List::MoreUtils qw( all any ); # spent 35µs making 1 call to Moose::Util::TypeConstraints::BEGIN@5 # spent 29µs making 1 call to Exporter::import
6 | 3 | 20µs | 2 | 58µs | # spent 32µs (6+26) within Moose::Util::TypeConstraints::BEGIN@6 which was called # once (6µs+26µs) by Moose::Meta::Attribute::BEGIN@18 at line 6 use Scalar::Util qw( blessed reftype ); # spent 32µs making 1 call to Moose::Util::TypeConstraints::BEGIN@6 # spent 26µs making 1 call to Exporter::import
7 | 3 | 61µs | 2 | 43µs | # spent 25µs (7+18) within Moose::Util::TypeConstraints::BEGIN@7 which was called # once (7µs+18µs) by Moose::Meta::Attribute::BEGIN@18 at line 7 use Moose::Exporter; # spent 25µs making 1 call to Moose::Util::TypeConstraints::BEGIN@7 # spent 18µs making 1 call to Moose::Exporter::import
8 |  |  |  |  |
9 | 1 | 1µs |  |  | our $VERSION = '0.98';
10 | 1 | 16µs |  |  | $VERSION = eval $VERSION;
11 | 1 | 500ns |  |  | our $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!
21 |  |  |  |  | sub where (&);
22 |  |  |  |  | sub via (&);
23 |  |  |  |  | sub message (&);
24 |  |  |  |  | sub optimize_as (&);
25 |  |  |  |  |
26 |  |  |  |  | ## --------------------------------------------------------
27 |  |  |  |  |
28 | 3 | 19µs | 1 | 4µs | # spent 4µs within Moose::Util::TypeConstraints::BEGIN@28 which was called # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 28 use Moose::Meta::TypeConstraint; # spent 4µs making 1 call to Moose::Util::TypeConstraints::BEGIN@28
29 | 3 | 111µs | 1 | 1.84ms | # spent 1.84ms (688µs+1.15) within Moose::Util::TypeConstraints::BEGIN@29 which was called # once (688µs+1.15ms) by Moose::Meta::Attribute::BEGIN@18 at line 29 use Moose::Meta::TypeConstraint::Union; # spent 1.84ms making 1 call to Moose::Util::TypeConstraints::BEGIN@29
30 | 3 | 103µs | 1 | 2.22ms | # spent 2.22ms (455µs+1.76) within Moose::Util::TypeConstraints::BEGIN@30 which was called # once (455µs+1.76ms) by Moose::Meta::Attribute::BEGIN@18 at line 30 use Moose::Meta::TypeConstraint::Parameterized; # spent 2.22ms making 1 call to Moose::Util::TypeConstraints::BEGIN@30
31 | 3 | 18µs | 1 | 4µs | # spent 4µs within Moose::Util::TypeConstraints::BEGIN@31 which was called # once (4µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 31 use Moose::Meta::TypeConstraint::Parameterizable; # spent 4µs making 1 call to Moose::Util::TypeConstraints::BEGIN@31
32 | 3 | 98µs | 1 | 1.11ms | # spent 1.11ms (606µs+504µs) within Moose::Util::TypeConstraints::BEGIN@32 which was called # once (606µs+504µs) by Moose::Meta::Attribute::BEGIN@18 at line 32 use Moose::Meta::TypeConstraint::Class; # spent 1.11ms making 1 call to Moose::Util::TypeConstraints::BEGIN@32
33 | 3 | 99µs | 1 | 1.05ms | # spent 1.05ms (543µs+508µs) within Moose::Util::TypeConstraints::BEGIN@33 which was called # once (543µs+508µs) by Moose::Meta::Attribute::BEGIN@18 at line 33 use Moose::Meta::TypeConstraint::Role; # spent 1.05ms making 1 call to Moose::Util::TypeConstraints::BEGIN@33
34 | 3 | 104µs | 1 | 980µs | # spent 980µs (481+499) within Moose::Util::TypeConstraints::BEGIN@34 which was called # once (481µs+499µs) by Moose::Meta::Attribute::BEGIN@18 at line 34 use Moose::Meta::TypeConstraint::Enum; # spent 980µs making 1 call to Moose::Util::TypeConstraints::BEGIN@34
35 | 3 | 103µs | 1 | 1.34ms | # spent 1.34ms (631µs+708µs) within Moose::Util::TypeConstraints::BEGIN@35 which was called # once (631µs+708µs) by Moose::Meta::Attribute::BEGIN@18 at line 35 use Moose::Meta::TypeConstraint::DuckType; # spent 1.34ms making 1 call to Moose::Util::TypeConstraints::BEGIN@35
36 | 3 | 21µs | 1 | 7µs | # spent 7µs within Moose::Util::TypeConstraints::BEGIN@36 which was called # once (7µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 36 use Moose::Meta::TypeCoercion; # spent 7µs making 1 call to Moose::Util::TypeConstraints::BEGIN@36
37 | 3 | 17µs | 1 | 3µs | # spent 3µs within Moose::Util::TypeConstraints::BEGIN@37 which was called # once (3µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 37 use Moose::Meta::TypeCoercion::Union; # spent 3µs making 1 call to Moose::Util::TypeConstraints::BEGIN@37
38 | 3 | 97µs | 1 | 1.54ms | # spent 1.54ms (442µs+1.10) within Moose::Util::TypeConstraints::BEGIN@38 which was called # once (442µs+1.10ms) by Moose::Meta::Attribute::BEGIN@18 at line 38 use Moose::Meta::TypeConstraint::Registry; # spent 1.54ms making 1 call to Moose::Util::TypeConstraints::BEGIN@38
39 | 3 | 160µs | 1 | 597µs | # spent 597µs (523+73) within Moose::Util::TypeConstraints::BEGIN@39 which was called # once (523µs+73µs) by Moose::Meta::Attribute::BEGIN@18 at line 39 use Moose::Util::TypeConstraints::OptimizedConstraints; # spent 597µs making 1 call to Moose::Util::TypeConstraints::BEGIN@39
40 |  |  |  |  |
41 | 1 | 8µs | 1 | 887µs | Moose::Exporter->setup_import_methods( # spent 887µs 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 |  |  |  |  |
58 | 1 | 2µs | 1 | 327µs | my $REGISTRY = Moose::Meta::TypeConstraint::Registry->new; # spent 327µs making 1 call to Moose::Meta::TypeConstraint::Registry::new
59 |  |  |  |  |
60 |  |  |  |  | sub get_type_constraint_registry {$REGISTRY}
61 | 1 | 13µs | 1 | 900ns | # spent 14µs (13+900ns) within Moose::Util::TypeConstraints::list_all_type_constraints which was called # once (13µs+900ns) by Moose::Meta::Attribute::BEGIN@18 at line 812 sub list_all_type_constraints { keys %{ $REGISTRY->type_constraints } } # spent 900ns making 1 call to Moose::Meta::TypeConstraint::Registry::type_constraints
62 |  |  |  |  |
63 |  |  |  |  | sub export_type_constraints_as_functions {
64 |  |  |  |  | my $pkg = caller();
65 | 3 | 1.64ms | 2 | 41µs | # spent 24µs (8+17) within Moose::Util::TypeConstraints::BEGIN@65 which was called # once (8µs+17µs) by Moose::Meta::Attribute::BEGIN@18 at line 65 no strict 'refs'; # spent 24µs making 1 call to Moose::Util::TypeConstraints::BEGIN@65 # spent 17µ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 |  |  |  |  |
74 |  |  |  |  | # spent 1.70ms (40µs+1.66) within Moose::Util::TypeConstraints::create_type_constraint_union which was called # once (40µs+1.66ms) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217 sub create_type_constraint_union {
75 | 7 | 25µs |  |  | my @type_constraint_names;
76 |  |  |  |  |
77 |  |  |  |  | if ( scalar @_ == 1 && _detect_type_constraint_union( $_[0] ) ) { # spent 92µs making 1 call to Moose::Util::TypeConstraints::_parse_type_constraint_union # spent 9µs making 1 call to Moose::Util::TypeConstraints::_detect_type_constraint_union
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 | 1 | 900ns | 4 | 12µs | my @type_constraints = map { # spent 12µs making 2 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 6µs/call # spent 879µs making 2 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 439µs/call, recursion: max depth 1, time 879µs
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( # spent 669µs making 1 call to Moose::Meta::TypeConstraint::Union::new
95 |  |  |  |  | type_constraints => \@type_constraints );
96 |  |  |  |  | }
97 |  |  |  |  |
98 |  |  |  |  | # spent 3.11ms (67µs+3.04) within Moose::Util::TypeConstraints::create_parameterized_type_constraint which was called 3 times, avg 1.04ms/call: # 3 times (67µs+3.04ms) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217, avg 1.04ms/call sub create_parameterized_type_constraint {
99 | 18 | 46µs |  |  | my $type_constraint_name = shift;
100 |  |  |  |  | my ( $base_type, $type_parameter ) # spent 79µs making 3 calls to Moose::Util::TypeConstraints::_parse_parameterized_type_constraint, avg 26µs/call
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) ) { # spent 18µs making 3 calls to Moose::Meta::TypeConstraint::Registry::has_type_constraint, avg 6µs/call
108 |  |  |  |  | my $base_type_tc = $REGISTRY->get_type_constraint($base_type); # spent 16µs making 3 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 5µs/call
109 |  |  |  |  | return _create_parameterized_type_constraint( # spent 2.93ms making 3 calls to Moose::Util::TypeConstraints::_create_parameterized_type_constraint, avg 976µs/call
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 |  |  |  |  |
120 |  |  |  |  | # spent 2.93ms (42µs+2.89) within Moose::Util::TypeConstraints::_create_parameterized_type_constraint which was called 3 times, avg 976µs/call: # 3 times (42µs+2.89ms) by Moose::Util::TypeConstraints::create_parameterized_type_constraint at line 109, avg 976µs/call sub _create_parameterized_type_constraint {
121 | 6 | 46µs |  |  | my ( $base_type_tc, $type_parameter ) = @_;
122 |  |  |  |  | if ( $base_type_tc->can('parameterize') ) { # spent 2.88ms making 3 calls to Moose::Meta::TypeConstraint::Parameterizable::parameterize, avg 960µs/call # spent 4µs making 3 calls to UNIVERSAL::can, avg 1µs/call
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 3.75ms (352µs+3.40) within Moose::Util::TypeConstraints::create_class_type_constraint which was called 28 times, avg 134µs/call: # 27 times (338µs+3.28ms) by Moose::Util::TypeConstraints::class_type at line 337, avg 134µs/call # once (13µs+114µs) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 203 sub create_class_type_constraint {
137 | 112 | 330µs |  |  | 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 3.40ms making 28 calls to Moose::Meta::TypeConstraint::Class::new, avg 121µs/call
152 |  |  |  |  | }
153 |  |  |  |  |
154 |  |  |  |  | # spent 2.13ms (197µs+1.93) within Moose::Util::TypeConstraints::create_role_type_constraint which was called 22 times, avg 97µs/call: # 22 times (197µs+1.93ms) by Moose::Util::TypeConstraints::role_type at line 346, avg 97µs/call sub create_role_type_constraint {
155 | 88 | 185µ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 1.93ms making 22 calls to Moose::Meta::TypeConstraint::Role::new, avg 88µs/call
170 |  |  |  |  | }
171 |  |  |  |  |
172 |  |  |  |  | # spent 1.46ms (45µs+1.41) within Moose::Util::TypeConstraints::find_or_create_type_constraint which was called 6 times, avg 243µs/call: # 4 times (26µs+142µs) by MooseX::Types::create_arged_type_constraint at line 429 of MooseX/Types.pm, avg 42µs/call # 2 times (20µs+1.27ms) by MooseX::AttributeHelpers::Trait::Base::process_options_for_provides at line 65 of MooseX/AttributeHelpers/Trait/Base.pm, avg 646µs/call sub find_or_create_type_constraint {
173 | 12 | 20µs |  |  | my ( $type_constraint_name, $options_for_anon_type ) = @_;
174 |  |  |  |  |
175 | 1 | 16µs | 12 | 1.41ms | if ( my $constraint # spent 1.39ms making 6 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 232µs/call # spent 23µs making 6 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 4µ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 7.37ms (525µs+6.85) within Moose::Util::TypeConstraints::find_or_create_isa_type_constraint which was called 87 times, avg 85µs/call: # 61 times (379µs+4.32ms) by Moose::Meta::Attribute::_process_options at line 307 of Moose/Meta/Attribute.pm, avg 77µs/call # 19 times (100µs+2.12ms) by Moose::Util::TypeConstraints::_create_type_constraint at line 523, avg 117µs/call # 7 times (46µs+400µs) by Moose::Meta::TypeConstraint::Parameterizable::_parse_type_parameter at line 47 of Moose/Meta/TypeConstraint/Parameterizable.pm, avg 64µs/call sub find_or_create_isa_type_constraint {
202 | 174 | 215µs |  |  | my $type_constraint_name = shift;
203 | 1 | 168µs | 174 | 6.84ms | find_or_parse_type_constraint($type_constraint_name) # spent 6.44ms making 87 calls to Moose::Util::TypeConstraints::find_or_parse_type_constraint, avg 74µs/call, recursion: max depth 2, time 102µs # spent 322µs making 82 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 4µs/call # spent 127µs making 1 call to Moose::Util::TypeConstraints::create_class_type_constraint # spent 44µs making 4 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:20], avg 11µs/call
204 |  |  |  |  | || create_class_type_constraint($type_constraint_name);
205 |  |  |  |  | }
206 |  |  |  |  |
207 |  |  |  |  | sub 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 7.73ms (860µs+6.87) within Moose::Util::TypeConstraints::find_or_parse_type_constraint which was called 95 times, avg 81µs/call: # 87 times (760µs+5.58ms) by Moose::Util::TypeConstraints::find_or_create_isa_type_constraint at line 203, avg 73µs/call # 6 times (70µs+1.32ms) by Moose::Util::TypeConstraints::find_or_create_type_constraint at line 175, avg 232µs/call # 2 times (29µs+-29µs) by Moose::Util::TypeConstraints::create_type_constraint_union at line 88, avg 0s/call sub find_or_parse_type_constraint {
214 | 294 | 453µs | 95 | 474µs | my $type_constraint_name = normalize_type_constraint_name(shift); # spent 474µs making 95 calls to Moose::Util::TypeConstraints::normalize_type_constraint_name, avg 5µs/call
215 |  |  |  |  | my $constraint;
216 |  |  |  |  |
217 | 1 | 198µs | 198 | 7.25ms | if ( $constraint = find_type_constraint($type_constraint_name) ) { # spent 3.11ms making 3 calls to Moose::Util::TypeConstraints::create_parameterized_type_constraint, avg 1.04ms/call # spent 1.70ms making 1 call to Moose::Util::TypeConstraints::create_type_constraint_union # spent 1.68ms making 95 calls to Moose::Util::TypeConstraints::find_type_constraint, avg 18µs/call # spent 484µs making 86 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 6µs/call # spent 144µs making 5 calls to Moose::Util::TypeConstraints::_detect_type_constraint_union, avg 29µs/call # spent 91µs making 4 calls to Moose::Util::TypeConstraints::_detect_parameterized_type_constraint, avg 23µs/call # spent 45µs making 4 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:20], avg 11µs/call
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); # spent 129µs making 4 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 32µs/call
232 |  |  |  |  | return $constraint;
233 |  |  |  |  | }
234 |  |  |  |  |
235 |  |  |  |  | # spent 474µs (330+144) within Moose::Util::TypeConstraints::normalize_type_constraint_name which was called 95 times, avg 5µs/call: # 95 times (330µs+144µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 214, avg 5µs/call sub normalize_type_constraint_name {
236 | 285 | 465µs |  |  | my $type_constraint_name = shift;
237 | 1 | 8µs | 99 | 194µs | $type_constraint_name =~ s/\s//g; # spent 144µs making 95 calls to Moose::Util::TypeConstraints::CORE:subst, avg 2µs/call # spent 51µs making 4 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:20], avg 13µs/call
238 |  |  |  |  | return $type_constraint_name;
239 |  |  |  |  | }
240 |  |  |  |  |
241 |  |  |  |  | sub _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 8.86ms (3.72+5.14) within Moose::Util::TypeConstraints::find_type_constraint which was called 510 times, avg 17µs/call: # 112 times (1.16ms+1.67ms) by MooseX::Types::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/MooseX/Types.pm:486] at line 479 of MooseX/Types.pm, avg 25µs/call # 95 times (663µs+1.02ms) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217, avg 18µs/call # 64 times (429µs+601µs) by MooseX::Types::create_base_type_constraint at line 452 of MooseX/Types.pm, avg 16µs/call # 54 times (221µs+60µs) by Moose::Meta::TypeConstraint::equals at line 134 of Moose/Meta/TypeConstraint.pm, avg 5µs/call # 52 times (332µs+489µs) by MooseX::Types::Base::import at line 63 of MooseX/Types/Base.pm, avg 16µs/call # 28 times (210µs+307µs) by Moose::Meta::TypeConstraint::Class::new at line 23 of Moose/Meta/TypeConstraint/Class.pm, avg 18µs/call # 27 times (203µs+254µs) by Moose::init_meta at line 155 of Moose.pm, avg 17µs/call # 22 times (158µs+235µs) by Moose::Meta::TypeConstraint::Role::new at line 23 of Moose/Meta/TypeConstraint/Role.pm, avg 18µs/call # 22 times (142µs+168µs) by Moose::Role::init_meta at line 116 of Moose/Role.pm, avg 14µs/call # 17 times (115µs+156µs) by Moose::Meta::TypeConstraint::is_subtype_of at line 165 of Moose/Meta/TypeConstraint.pm, avg 16µs/call # 10 times (45µs+121µs) by Moose::Util::TypeConstraints::_install_type_coercions at line 544, avg 17µs/call # 2 times (14µs+20µs) by Moose::Meta::TypeConstraint::is_a_type_of at line 157 of Moose/Meta/TypeConstraint.pm, avg 17µs/call # once (7µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 731 # once (7µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 752 # once (7µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 790 # once (7µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 773 # once (4µs+1µs) by Moose::Meta::TypeConstraint::Parameterized::equals at line 25 of Moose/Meta/TypeConstraint/Parameterized.pm sub find_type_constraint {
253 | 1827 | 3.55ms |  |  | my $type = shift;
254 |  |  |  |  |
255 |  |  |  |  | if ( blessed $type and $type->isa("Moose::Meta::TypeConstraint") ) { # spent 266µs making 510 calls to Scalar::Util::blessed, avg 522ns/call # spent 163µs making 14 calls to MooseX::Types::TypeDecorator::isa, avg 12µs/call # spent 37µs making 56 calls to UNIVERSAL::isa, avg 655ns/call
256 |  |  |  |  | return $type;
257 |  |  |  |  | }
258 |  |  |  |  | else {
259 |  |  |  |  | return unless $REGISTRY->has_type_constraint($type); # spent 2.79ms making 440 calls to Moose::Meta::TypeConstraint::Registry::has_type_constraint, avg 6µs/call
260 |  |  |  |  | return $REGISTRY->get_type_constraint($type); # spent 1.88ms making 367 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 5µs/call
261 |  |  |  |  | }
262 |  |  |  |  | }
263 |  |  |  |  |
264 |  |  |  |  | # spent 1.65ms (400µs+1.25) within Moose::Util::TypeConstraints::register_type_constraint which was called 49 times, avg 34µs/call: # 27 times (247µs+709µs) by Moose::Util::TypeConstraints::class_type at line 337, avg 35µs/call # 22 times (152µs+537µs) by Moose::Util::TypeConstraints::role_type at line 346, avg 31µs/call sub register_type_constraint {
265 | 196 | 300µs |  |  | my $constraint = shift;
266 |  |  |  |  | __PACKAGE__->_throw_error("can't register an unnamed type constraint") # spent 95µs making 49 calls to Moose::Meta::TypeConstraint::name, avg 2µs/call
267 |  |  |  |  | unless defined $constraint->name;
268 |  |  |  |  | $REGISTRY->add_type_constraint($constraint); # spent 1.15ms making 49 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 24µs/call
269 |  |  |  |  | return $constraint;
270 |  |  |  |  | }
271 |  |  |  |  |
272 |  |  |  |  | # type constructors
273 |  |  |  |  |
274 |  |  |  |  | # spent 279µs (21+258) within Moose::Util::TypeConstraints::type which was called # once (21µs+258µs) by Moose::Meta::Attribute::BEGIN@18 at line 650 sub type {
275 |  |  |  |  |
276 |  |  |  |  | # back-compat version, called without sugar
277 | 6 | 51µs | 3 | 33µs | if ( !any { ( reftype($_) || '' ) eq 'HASH' } @_ ) { # spent 31µs making 1 call to List::MoreUtils::any # spent 2µs making 2 calls to Scalar::Util::reftype, avg 750ns/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 227µs 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 7.92ms (608µs+7.31) within Moose::Util::TypeConstraints::subtype which was called 28 times, avg 283µs/call: # 10 times (225µs+2.83ms) by MooseX::Types::CheckedUtilExports::subtype at line 62 of MooseX/Types/CheckedUtilExports.pm, avg 306µs/call # once (27µs+1.75ms) by MooseX::AttributeHelpers::BEGIN@21 at line 21 of MooseX/AttributeHelpers/Trait/Collection/Bag.pm # once (38µs+257µs) by Moose::Meta::Attribute::BEGIN@18 at line 651 # once (24µs+190µs) by Moose::Meta::Attribute::BEGIN@18 at line 653 # once (19µs+194µs) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (20µs+192µs) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (26µs+149µs) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (19µs+156µs) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (19µs+155µs) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (19µs+149µs) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (18µs+149µs) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (24µs+143µs) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (19µs+143µs) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (19µs+142µs) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (19µs+142µs) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (18µs+141µs) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (18µs+141µs) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (18µs+141µs) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (18µs+141µ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 };
296 | 224 | 534µs | 8 | 6µs | if ( scalar @_ == 2 && ( reftype( $_[1] ) || '' ) eq 'CODE' ) { # spent 6µs making 8 calls to Scalar::Util::reftype, avg 700ns/call
297 |  |  |  |  | return _create_type_constraint( undef, @_ );
298 |  |  |  |  | }
299 |  |  |  |  |
300 |  |  |  |  | # subtype 'Parent', sub { where }, sub { message };
301 |  |  |  |  | # subtype 'Parent', sub { where }, sub { message }, sub { optimized };
302 | 20 | 117µs | 40 | 100µs | if ( scalar @_ >= 3 && all { ( reftype($_) || '' ) eq 'CODE' } # spent 86µs making 20 calls to List::MoreUtils::all, avg 4µs/call # spent 14µs making 20 calls to Scalar::Util::reftype, avg 685ns/call
303 |  |  |  |  | @_[ 1 .. $#_ ] ) {
304 |  |  |  |  | return _create_type_constraint( undef, @_ );
305 |  |  |  |  | }
306 |  |  |  |  |
307 |  |  |  |  | # subtype 'Name', 'Parent', ...
308 | 46 | 89µs | 28 | 47µs | if ( scalar @_ >= 2 && all { !ref } @_[ 0, 1 ] ) { # spent 47µs making 28 calls to List::MoreUtils::all, avg 2µ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; # spent 5µs making 10 calls to Scalar::Util::blessed, avg 520ns/call
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 7.16ms making 28 calls to Moose::Util::TypeConstraints::_create_type_constraint, avg 256µs/call
331 |  |  |  |  | $name, $p{as}, $p{where}, $p{message},
332 |  |  |  |  | $p{optimize_as}
333 |  |  |  |  | );
334 |  |  |  |  | }
335 |  |  |  |  |
336 |  |  |  |  | # spent 4.76ms (186µs+4.58) within Moose::Util::TypeConstraints::class_type which was called 27 times, avg 176µs/call: # 26 times (179µs+4.37ms) by Moose::init_meta at line 155 of Moose.pm, avg 175µs/call # once (8µs+207µs) by MooseX::Types::CheckedUtilExports::class_type at line 73 of MooseX/Types/CheckedUtilExports.pm sub class_type {
337 | 27 | 163µs | 54 | 4.58ms | register_type_constraint( # spent 3.62ms making 27 calls to Moose::Util::TypeConstraints::create_class_type_constraint, avg 134µs/call # spent 957µs making 27 calls to Moose::Util::TypeConstraints::register_type_constraint, avg 35µs/call
338 |  |  |  |  | create_class_type_constraint(
339 |  |  |  |  | $_[0],
340 |  |  |  |  | ( defined( $_[1] ) ? $_[1] : () ),
341 |  |  |  |  | )
342 |  |  |  |  | );
343 |  |  |  |  | }
344 |  |  |  |  |
345 |  |  |  |  | # spent 2.94ms (116µs+2.82) within Moose::Util::TypeConstraints::role_type which was called 22 times, avg 133µs/call: # 22 times (116µs+2.82ms) by Moose::Role::init_meta at line 116 of Moose/Role.pm, avg 133µs/call sub role_type ($;$) {
346 | 22 | 92µs | 44 | 2.82ms | register_type_constraint( # spent 2.13ms making 22 calls to Moose::Util::TypeConstraints::create_role_type_constraint, avg 97µs/call # spent 690µs making 22 calls to Moose::Util::TypeConstraints::register_type_constraint, avg 31µs/call
347 |  |  |  |  | create_role_type_constraint(
348 |  |  |  |  | $_[0],
349 |  |  |  |  | ( defined( $_[1] ) ? $_[1] : () ),
350 |  |  |  |  | )
351 |  |  |  |  | );
352 |  |  |  |  | }
353 |  |  |  |  |
354 |  |  |  |  | sub maybe_type {
355 |  |  |  |  | my ($type_parameter) = @_;
356 |  |  |  |  |
357 |  |  |  |  | register_type_constraint(
358 |  |  |  |  | $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
359 |  |  |  |  | );
360 |  |  |  |  | }
361 |  |  |  |  |
362 |  |  |  |  | sub 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 |  |  |  |  |
380 |  |  |  |  | # spent 3.37ms (37µs+3.33) within Moose::Util::TypeConstraints::coerce which was called 10 times, avg 337µs/call: # 10 times (37µs+3.33ms) by MooseX::Types::CheckedUtilExports::coerce at line 62 of MooseX/Types/CheckedUtilExports.pm, avg 337µs/call sub coerce {
381 | 20 | 37µs |  |  | my ( $type_name, @coercion_map ) = @_;
382 |  |  |  |  | _install_type_coercions( $type_name, \@coercion_map ); # spent 3.33ms making 10 calls to Moose::Util::TypeConstraints::_install_type_coercions, avg 333µs/call
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.
398 | 28 | 82µs |  |  | # spent 53µs within Moose::Util::TypeConstraints::as which was called 28 times, avg 2µs/call: # 10 times (18µs+0s) by MooseX::Types::CheckedUtilExports::as at line 62 of MooseX/Types/CheckedUtilExports.pm, avg 2µs/call # once (3µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 651 # once (3µs+0s) by MooseX::AttributeHelpers::BEGIN@21 at line 21 of MooseX/AttributeHelpers/Trait/Collection/Bag.pm # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 653 sub as { { as => shift }, @_ }
399 | 21 | 64µs |  |  | # spent 34µs within Moose::Util::TypeConstraints::where which was called 21 times, avg 2µs/call: # once (3µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 650 # once (3µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 89 of ../lib/SimpleDB/Class/Types.pm # once (2µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 108 of ../lib/SimpleDB/Class/Types.pm # once (2µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 93 of ../lib/SimpleDB/Class/Types.pm # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 653 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 657 # once (2µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 112 of ../lib/SimpleDB/Class/Types.pm # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 654 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666 sub where (&) { { where => $_[0] } }
400 |  |  |  |  | sub message (&) { { message => $_[0] } }
401 | 13 | 34µs |  |  | # spent 16µs within Moose::Util::TypeConstraints::optimize_as which was called 13 times, avg 1µs/call: # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 660 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 709 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 673 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 704 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 676 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 695 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 681 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 670 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 699 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 688 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 666 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 678 # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 663 sub optimize_as (&) { { optimize_as => $_[0] } }
402 |  |  |  |  |
403 | 30 | 53µs |  |  | # spent 32µs within Moose::Util::TypeConstraints::from which was called 30 times, avg 1µs/call: # 30 times (32µs+0s) by MooseX::Types::CheckedUtilExports::from at line 62 of MooseX/Types/CheckedUtilExports.pm, avg 1µs/call sub from {@_}
404 | 30 | 55µs |  |  | # spent 31µs within Moose::Util::TypeConstraints::via which was called 30 times, avg 1µs/call: # 5 times (6µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 156 of ../lib/SimpleDB/Class/Types.pm, avg 1µs/call # 4 times (4µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 188 of ../lib/SimpleDB/Class/Types.pm, avg 1µs/call # 4 times (4µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 208 of ../lib/SimpleDB/Class/Types.pm, avg 925ns/call # 4 times (4µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 165 of ../lib/SimpleDB/Class/Types.pm, avg 900ns/call # 3 times (4µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 171 of ../lib/SimpleDB/Class/Types.pm, avg 1µs/call # 3 times (3µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 222 of ../lib/SimpleDB/Class/Types.pm, avg 967ns/call # 2 times (2µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 192 of ../lib/SimpleDB/Class/Types.pm, avg 1µs/call # 2 times (2µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 175 of ../lib/SimpleDB/Class/Types.pm, avg 1µs/call # once (1µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 159 of ../lib/SimpleDB/Class/Types.pm # once (1µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 166 of ../lib/SimpleDB/Class/Types.pm # once (1µs+0s) by SimpleDB::Class::Role::Itemized::BEGIN@4 at line 195 of ../lib/SimpleDB/Class/Types.pm sub via (&) { $_[0] }
405 |  |  |  |  |
406 |  |  |  |  | sub 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 |  |  |  |  |
433 |  |  |  |  | sub 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 |  |  |  |  |
442 |  |  |  |  | sub 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 |  |  |  |  |
451 |  |  |  |  | sub 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 7.39ms (678µs+6.71) within Moose::Util::TypeConstraints::_create_type_constraint which was called 29 times, avg 255µs/call: # 28 times (647µs+6.52ms) by Moose::Util::TypeConstraints::subtype at line 330, avg 256µs/call # once (31µs+196µs) by Moose::Util::TypeConstraints::type at line 285 sub _create_type_constraint ($$$;$$) {
489 | 436 | 510µs |  |  | 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 |  |  |  |  |
497 |  |  |  |  | if ( defined $name ) {
498 |  |  |  |  | my $type = $REGISTRY->get_type_constraint($name); # spent 330µs making 29 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 11µ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 | 1 | 47µs | 39 | 334µs | $name =~ /^[\w:\.]+$/ # spent 212µs making 29 calls to Moose::Util::TypeConstraints::CORE:match, avg 7µs/call # spent 122µs making 10 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:20], avg 12µ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;
523 | 1 | 68µs | 103 | 5.42ms | if ( # spent 2.22ms making 19 calls to Moose::Util::TypeConstraints::find_or_create_isa_type_constraint, avg 117µs/call # spent 1.60ms making 9 calls to MooseX::Types::TypeDecorator::AUTOLOAD, avg 178µs/call # spent 1.05ms making 17 calls to Moose::Meta::TypeConstraint::create_child_type, avg 62µs/call # spent 196µs making 1 call to Moose::Meta::TypeConstraint::Parameterized::create_child_type # spent 153µs making 1 call to Moose::Meta::TypeConstraint::Class::create_child_type # spent 111µs making 9 calls to MooseX::Types::TypeDecorator::__ANON__[MooseX/Types/TypeDecorator.pm:20], avg 12µs/call # spent 70µs making 19 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 4µs/call # spent 17µs making 28 calls to Scalar::Util::blessed, avg 604ns/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 149µs making 1 call to Moose::Meta::TypeConstraint::new
534 |  |  |  |  | }
535 |  |  |  |  |
536 |  |  |  |  | $REGISTRY->add_type_constraint($constraint) # spent 606µs making 29 calls to Moose::Meta::TypeConstraint::Registry::add_type_constraint, avg 21µs/call
537 |  |  |  |  | if defined $name;
538 |  |  |  |  |
539 |  |  |  |  | return $constraint;
540 |  |  |  |  | }
541 |  |  |  |  |
542 |  |  |  |  | # spent 3.33ms (130µs+3.20) within Moose::Util::TypeConstraints::_install_type_coercions which was called 10 times, avg 333µs/call: # 10 times (130µs+3.20ms) by Moose::Util::TypeConstraints::coerce at line 382, avg 333µs/call sub _install_type_coercions ($$) {
543 | 60 | 90µs |  |  | my ( $type_name, $coercion_map ) = @_;
544 |  |  |  |  | my $type = find_type_constraint($type_name); # spent 166µs making 10 calls to Moose::Util::TypeConstraints::find_type_constraint, avg 17µs/call
545 |  |  |  |  | ( defined $type )
546 |  |  |  |  | || __PACKAGE__->_throw_error(
547 |  |  |  |  | "Cannot find type '$type_name', perhaps you forgot to load it");
548 |  |  |  |  | if ( $type->has_coercion ) { # spent 188µs making 10 calls to MooseX::Types::TypeDecorator::AUTOLOAD, avg 19µs/call
549 |  |  |  |  | $type->coercion->add_type_coercions(@$coercion_map);
550 |  |  |  |  | }
551 |  |  |  |  | else {
552 |  |  |  |  | my $type_coercion = Moose::Meta::TypeCoercion->new( # spent 2.67ms making 10 calls to Moose::Meta::TypeCoercion::new, avg 267µs/call
553 |  |  |  |  | type_coercion_map => $coercion_map,
554 |  |  |  |  | type_constraint => $type
555 |  |  |  |  | );
556 |  |  |  |  | $type->coercion($type_coercion); # spent 179µs making 10 calls to MooseX::Types::TypeDecorator::AUTOLOAD, avg 18µs/call
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 |  |  |  |  |
572 | 4 | 212µs | 6 | 927µs | # spent 912µs (860+51) within Moose::Util::TypeConstraints::BEGIN@572 which was called # once (860µs+51µs) by Moose::Meta::Attribute::BEGIN@18 at line 572 use re "eval"; # spent 912µs making 1 call to Moose::Util::TypeConstraints::BEGIN@572 # spent 14µs making 1 call to re::import # spent 2µs making 4 calls to Regexp::DESTROY, avg 475ns/call
573 |  |  |  |  |
574 | 1 | 17µs | 1 | 5µs | my $valid_chars = qr{[\w:\.]}; # spent 5µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
575 | 1 | 19µs | 2 | 14µs | my $type_atom = qr{ (?>$valid_chars+) }x; # spent 13µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
576 | 1 | 3µs | 1 | 900ns | my $ws = qr{ (?>\s*) }x; # spent 900ns making 1 call to Moose::Util::TypeConstraints::CORE:qr
577 |  |  |  |  |
578 | 1 | 100ns |  |  | my $any;
579 |  |  |  |  |
580 | 1 | 38µs | 2 | 32µs | my $type = qr{ $type_atom (?: \[ $ws (??{$any}) $ws \] )? }x; # spent 31µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
581 | 1 | 38µs | 2 | 32µs | my $type_capture_parts # spent 30µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
582 |  |  |  |  | = qr{ ($type_atom) (?: \[ $ws ((??{$any})) $ws \] )? }x;
583 | 1 | 44µs | 2 | 37µs | my $type_with_parameter # spent 36µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 2µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
584 |  |  |  |  | = qr{ $type_atom \[ $ws (??{$any}) $ws \] }x;
585 |  |  |  |  |
586 | 1 | 14µs | 2 | 10µs | my $op_union = qr{ $ws \| $ws }x; # spent 8µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
587 | 1 | 67µs | 2 | 59µs | my $union = qr{ $type (?> (?: $op_union $type )+ ) }x; # spent 58µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
588 |  |  |  |  |
589 | 1 | 91µs | 2 | 70µs | $any = qr{ $type | $union }x; # spent 68µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 1µs making 1 call to Moose::Util::TypeConstraints::CORE:qr
590 |  |  |  |  |
591 |  |  |  |  | # spent 79µs (34+44) within Moose::Util::TypeConstraints::_parse_parameterized_type_constraint which was called 3 times, avg 26µs/call: # 3 times (34µs+44µs) by Moose::Util::TypeConstraints::create_parameterized_type_constraint at line 100, avg 26µs/call sub _parse_parameterized_type_constraint {
592 | 15 | 116µs | 2 | 43µs | # spent 27µs (10+17) within Moose::Util::TypeConstraints::BEGIN@592 which was called # once (10µs+17µs) by Moose::Meta::Attribute::BEGIN@18 at line 592 { no warnings 'void'; $any; } # force capture of interpolated lexical # spent 27µs making 1 call to Moose::Util::TypeConstraints::BEGIN@592 # spent 16µs making 1 call to warnings::unimport
593 | 1 | 18µs | 6 | 44µs | $_[0] =~ m{ $type_capture_parts }x; # spent 28µs making 3 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 9µs/call # spent 16µs making 3 calls to Moose::Util::TypeConstraints::CORE:match, avg 5µs/call
594 |  |  |  |  | return ( $1, $2 );
595 |  |  |  |  | }
596 |  |  |  |  |
597 |  |  |  |  | # spent 91µs (31+59) within Moose::Util::TypeConstraints::_detect_parameterized_type_constraint which was called 4 times, avg 23µs/call: # 4 times (31µs+59µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217, avg 23µs/call sub _detect_parameterized_type_constraint {
598 | 15 | 115µs | 2 | 26µs | # spent 18µs (10+8) within Moose::Util::TypeConstraints::BEGIN@598 which was called # once (10µs+8µs) by Moose::Meta::Attribute::BEGIN@18 at line 598 { no warnings 'void'; $any; } # force capture of interpolated lexical # spent 18µs making 1 call to Moose::Util::TypeConstraints::BEGIN@598 # spent 8µs making 1 call to warnings::unimport
599 | 1 | 28µs | 8 | 59µs | $_[0] =~ m{ ^ $type_with_parameter $ }x; # spent 34µs making 4 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 9µs/call # spent 25µs making 4 calls to Moose::Util::TypeConstraints::CORE:match, avg 6µs/call
600 |  |  |  |  | }
601 |  |  |  |  |
602 |  |  |  |  | # spent 92µs (28+64) within Moose::Util::TypeConstraints::_parse_type_constraint_union which was called # once (28µs+64µs) by Moose::Util::TypeConstraints::create_type_constraint_union at line 77 sub _parse_type_constraint_union {
603 | 12 | 175µs | 2 | 25µs | # spent 16µs (8+8) within Moose::Util::TypeConstraints::BEGIN@603 which was called # once (8µs+8µs) by Moose::Meta::Attribute::BEGIN@18 at line 603 { no warnings 'void'; $any; } # force capture of interpolated lexical # spent 16µs making 1 call to Moose::Util::TypeConstraints::BEGIN@603 # spent 8µs making 1 call to warnings::unimport
604 |  |  |  |  | my $given = shift;
605 |  |  |  |  | my @rv;
606 | 1 | 4µs | 2 | 59µs | while ( $given =~ m{ \G (?: $op_union )? ($type) }gcx ) { # spent 56µs making 1 call to Moose::Util::TypeConstraints::CORE:regcomp # spent 3µs making 1 call to Moose::Util::TypeConstraints::CORE:match
607 |  |  |  |  | push @rv => $1; # spent 4µs making 2 calls to Moose::Util::TypeConstraints::CORE:match, avg 2µs/call # spent 1µs making 2 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 650ns/call
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 152µs (44+108) within Moose::Util::TypeConstraints::_detect_type_constraint_union which was called 6 times, avg 25µs/call: # 5 times (40µs+104µs) by Moose::Util::TypeConstraints::find_or_parse_type_constraint at line 217, avg 29µs/call # once (4µs+5µs) by Moose::Util::TypeConstraints::create_type_constraint_union at line 77 sub _detect_type_constraint_union {
619 | 21 | 1.41ms | 2 | 26µs | # spent 17µs (8+9) within Moose::Util::TypeConstraints::BEGIN@619 which was called # once (8µs+9µs) by Moose::Meta::Attribute::BEGIN@18 at line 619 { no warnings 'void'; $any; } # force capture of interpolated lexical # spent 17µs making 1 call to Moose::Util::TypeConstraints::BEGIN@619 # spent 9µs making 1 call to warnings::unimport
620 | 1 | 17µs | 12 | 108µs | $_[0] =~ m{^ $type $op_union $type ( $op_union .* )? $}x; # spent 87µs making 6 calls to Moose::Util::TypeConstraints::CORE:regcomp, avg 15µs/call # spent 21µs making 6 calls to Moose::Util::TypeConstraints::CORE:match, avg 4µs/call
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 | 9 | 8µs | 9 | 6µs | inline_constructor => 1, # spent 6µs making 9 calls to Class::MOP::Class::is_mutable, avg 678ns/call
632 |  |  |  |  | constructor_name => "_new",
633 |  |  |  |  |
634 |  |  |  |  | # these are Class::MOP accessors, so they need inlining
635 |  |  |  |  | inline_accessors => 1
636 | 10 | 26µs | 18 | 22.1ms | ) for grep { $_->is_mutable } # spent 22.1ms making 9 calls to Class::MOP::Class::make_immutable, avg 2.45ms/call # spent 32µs making 9 calls to Class::MOP::class_of, avg 4µ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
648 | 1 | 0s |  |  | );
649 |  |  |  |  |
650 | 16 | 66µs | 2 | 282µs | # spent 41µs within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:650] which was called 15 times, avg 3µs/call: # 15 times (41µs+0s) by Moose::Meta::TypeConstraint::Bool or Moose::Meta::TypeConstraint::Undef at line 263 of Moose/Meta/TypeConstraint.pm, avg 3µs/call type 'Any' => where {1}; # meta-type including all # spent 279µs making 1 call to Moose::Util::TypeConstraints::type # spent 3µs making 1 call to Moose::Util::TypeConstraints::where
651 | 1 | 6µs | 2 | 299µs | subtype 'Item' => as 'Any'; # base-type # spent 295µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 3µs making 1 call to Moose::Util::TypeConstraints::as
652 |  |  |  |  |
653 | 6 | 33µs | 3 | 217µs | # spent 20µs within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:653] which was called 5 times, avg 4µs/call: # 5 times (20µs+0s) by Moose::Meta::TypeConstraint::Undef at line 263 of Moose/Meta/TypeConstraint.pm, avg 4µs/call subtype 'Undef' => as 'Item' => where { !defined($_) }; # spent 214µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where
654 | 1 | 7µs | 3 | 215µs | subtype 'Defined' => as 'Item' => where { defined($_) }; # spent 212µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where
655 |  |  |  |  |
656 |  |  |  |  | subtype 'Bool' => as 'Item' =>
657 | 11 | 59µs | 3 | 217µs | # spent 44µs within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:657] which was called 10 times, avg 4µs/call: # 10 times (44µs+0s) by Moose::Meta::TypeConstraint::Bool at line 263 of Moose/Meta/TypeConstraint.pm, avg 4µs/call where { !defined($_) || $_ eq "" || "$_" eq '1' || "$_" eq '0' }; # spent 213µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where
658 |  |  |  |  |
659 |  |  |  |  | subtype 'Value' => as 'Defined' => where { !ref($_) } =>
660 | 1 | 9µs | 4 | 180µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Value; # spent 174µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::optimize_as # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 1µs making 1 call to Moose::Util::TypeConstraints::where
661 |  |  |  |  |
662 |  |  |  |  | subtype 'Ref' => as 'Defined' => where { ref($_) } =>
663 | 1 | 8µs | 4 | 163µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Ref; # spent 159µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 1µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
664 |  |  |  |  |
665 |  |  |  |  | subtype 'Str' => as 'Value' => where { ref(\$_) eq 'SCALAR' } =>
666 | 1 | 8µs | 4 | 179µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Str; # spent 175µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 1µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
667 |  |  |  |  |
668 |  |  |  |  | subtype 'Num' => as 'Str' =>
669 |  |  |  |  | where { Scalar::Util::looks_like_number($_) } =>
670 | 1 | 8µs | 4 | 166µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Num; # spent 161µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
671 |  |  |  |  |
672 |  |  |  |  | subtype 'Int' => as 'Num' => where { "$_" =~ /^-?[0-9]+$/ } =>
673 | 1 | 9µs | 4 | 164µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Int; # spent 160µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
674 |  |  |  |  |
675 |  |  |  |  | subtype 'CodeRef' => as 'Ref' => where { ref($_) eq 'CODE' } =>
676 | 1 | 8µs | 4 | 164µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::CodeRef; # spent 159µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 1µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
677 |  |  |  |  | subtype 'RegexpRef' => as 'Ref' => where { ref($_) eq 'Regexp' } =>
678 | 1 | 8µs | 4 | 164µs | optimize_as # spent 159µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
679 |  |  |  |  | \&Moose::Util::TypeConstraints::OptimizedConstraints::RegexpRef;
680 |  |  |  |  | subtype 'GlobRef' => as 'Ref' => where { ref($_) eq 'GLOB' } =>
681 | 1 | 8µs | 4 | 172µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::GlobRef; # spent 168µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µ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
686 |  |  |  |  | subtype 'FileHandle' => as 'GlobRef' => where {
687 |  |  |  |  | Scalar::Util::openhandle($_) || ( blessed($_) && $_->isa("IO::Handle") );
688 | 1 | 8µs | 4 | 171µs | } => optimize_as # spent 167µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µ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
693 |  |  |  |  | subtype 'Object' => as 'Ref' =>
694 |  |  |  |  | where { blessed($_) && blessed($_) ne 'Regexp' } =>
695 | 1 | 9µs | 4 | 164µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Object; # spent 159µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
696 |  |  |  |  |
697 |  |  |  |  | # This type is deprecated.
698 |  |  |  |  | subtype 'Role' => as 'Object' => where { $_->can('does') } =>
699 | 1 | 9µs | 4 | 178µs | optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Role; # spent 174µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
700 |  |  |  |  |
701 | 1 | 3µs |  |  | my $_class_name_checker = sub { };
702 |  |  |  |  |
703 |  |  |  |  | subtype 'ClassName' => as 'Str' =>
704 | 1 | 8µs | 4 | 173µs | where { Class::MOP::is_class_loaded($_) } => optimize_as # spent 168µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µs making 1 call to Moose::Util::TypeConstraints::optimize_as
705 |  |  |  |  | \&Moose::Util::TypeConstraints::OptimizedConstraints::ClassName;
706 |  |  |  |  |
707 |  |  |  |  | subtype 'RoleName' => as 'ClassName' => where {
708 |  |  |  |  | (Class::MOP::class_of($_) || return)->isa('Moose::Meta::Role');
709 | 1 | 8µs | 4 | 166µs | } => optimize_as # spent 162µs making 1 call to Moose::Util::TypeConstraints::subtype # spent 2µs making 1 call to Moose::Util::TypeConstraints::as # spent 2µs making 1 call to Moose::Util::TypeConstraints::where # spent 1µ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 |  |  |  |  | )
731 | 1 | 15µs | 3 | 173µs | ); # spent 133µs making 1 call to Moose::Meta::TypeConstraint::new # spent 24µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 16µ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 133µs (48+85) within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:750] which was called 5 times, avg 27µs/call: # 5 times (48µs+85µs) by Moose::Meta::TypeConstraint::Parameterizable::generate_constraint_for at line 25 of Moose/Meta/TypeConstraint/Parameterizable.pm, avg 27µs/call constraint_generator => sub {
742 | 15 | 44µs |  |  | my $type_parameter = shift;
743 |  |  |  |  | my $check = $type_parameter->_compiled_type_constraint; # spent 83µs making 4 calls to MooseX::Types::TypeDecorator::AUTOLOAD, avg 21µs/call # spent 2µs making 1 call to Moose::Meta::TypeConstraint::_compiled_type_constraint
744 |  |  |  |  | # spent 1.95ms (717µs+1.23) within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:749] which was called 154 times, avg 13µs/call: # 154 times (717µs+1.23ms) by SimpleDB::Class::Types::SdbArrayRefOfDateTime or SimpleDB::Class::Types::SdbArrayRefOfStr at line 263 of Moose/Meta/TypeConstraint.pm, avg 13µs/call return sub {
745 | 409 | 623µs |  |  | foreach my $x (@$_) {
746 |  |  |  |  | ( $check->($x) ) || return; # spent 1.17ms making 101 calls to SimpleDB::Class::Types::SdbStr, avg 12µs/call # spent 60µs making 20 calls to Moose::Meta::TypeConstraint::Class::__ANON__[Moose/Meta/TypeConstraint/Class.pm:38], avg 3µs/call
747 |  |  |  |  | }
748 |  |  |  |  | 1;
749 |  |  |  |  | }
750 |  |  |  |  | }
751 |  |  |  |  | )
752 | 1 | 16µs | 3 | 79µs | ); # spent 44µs making 1 call to Moose::Meta::TypeConstraint::new # spent 19µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 16µ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 22µs (19+3) within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:771] which was called 2 times, avg 11µs/call: # 2 times (19µs+3µs) by Moose::Meta::TypeConstraint::Parameterizable::generate_constraint_for at line 25 of Moose/Meta/TypeConstraint/Parameterizable.pm, avg 11µs/call constraint_generator => sub {
763 | 6 | 16µs |  |  | my $type_parameter = shift;
764 |  |  |  |  | my $check = $type_parameter->_compiled_type_constraint; # spent 3µs making 2 calls to Moose::Meta::TypeConstraint::_compiled_type_constraint, avg 1µs/call
765 |  |  |  |  | # spent 10µs within Moose::Util::TypeConstraints::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Util/TypeConstraints.pm:770] which was called 2 times, avg 5µs/call: # 2 times (10µs+0s) by HashRef[Moose::Meta::Attribute] at line 252 of Moose/Meta/TypeConstraint.pm, avg 5µs/call return sub {
766 | 4 | 11µs |  |  | foreach my $x ( values %$_ ) {
767 |  |  |  |  | ( $check->($x) ) || return;
768 |  |  |  |  | }
769 |  |  |  |  | 1;
770 |  |  |  |  | }
771 |  |  |  |  | }
772 |  |  |  |  | )
773 | 1 | 8µs | 3 | 75µs | ); # spent 41µs making 1 call to Moose::Meta::TypeConstraint::new # spent 19µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 16µ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 |  |  |  |  | )
790 | 1 | 7µs | 3 | 143µs | ); # spent 107µs making 1 call to Moose::Meta::TypeConstraint::new # spent 21µs making 1 call to Moose::Meta::TypeConstraint::Registry::add_type_constraint # spent 16µs making 1 call to Moose::Util::TypeConstraints::find_type_constraint
791 |  |  |  |  |
792 |  |  |  |  | my @PARAMETERIZABLE_TYPES
793 | 5 | 6µs | 4 | 18µs | = map { $REGISTRY->get_type_constraint($_) } qw[ScalarRef ArrayRef HashRef Maybe]; # spent 18µs making 4 calls to Moose::Meta::TypeConstraint::Registry::get_type_constraint, avg 5µs/call
794 |  |  |  |  |
795 | 7 | 21µs |  |  | # spent 17µs within Moose::Util::TypeConstraints::get_all_parameterizable_types which was called 7 times, avg 2µs/call: # 7 times (17µs+0s) by Moose::Meta::TypeConstraint::Parameterized::compile_type_constraint at line 51 of Moose/Meta/TypeConstraint/Parameterized.pm, avg 2µs/call sub get_all_parameterizable_types {@PARAMETERIZABLE_TYPES}
796 |  |  |  |  |
797 |  |  |  |  | sub 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 |  |  |  |  | {
812 | 2 | 7µs | 1 | 14µs | my @BUILTINS = list_all_type_constraints(); # spent 14µs making 1 call to Moose::Util::TypeConstraints::list_all_type_constraints
813 | 1 | 11µs |  |  | # spent 9µs within Moose::Util::TypeConstraints::list_all_builtin_type_constraints which was called # once (9µs+0s) by SimpleDB::Class::Types::BEGIN@83 at line 51 of MooseX/Types/Moose.pm sub list_all_builtin_type_constraints {@BUILTINS}
814 |  |  |  |  | }
815 |  |  |  |  |
816 |  |  |  |  | sub _throw_error {
817 |  |  |  |  | shift;
818 |  |  |  |  | require Moose;
819 |  |  |  |  | unshift @_, 'Moose';
820 |  |  |  |  | goto &Moose::throw_error;
821 |  |  |  |  | }
822 |  |  |  |  |
823 | 1 | 165µs |  |  | 1;
824 |  |  |  |  |
825 |  |  |  |  | __END__
826 |  |  |  |  |
827 |  |  |  |  | =pod
828 |  |  |  |  |
829 |  |  |  |  | =head1 NAME
830 |  |  |  |  |
831 |  |  |  |  | Moose::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 |  |  |  |  |
856 |  |  |  |  | This module provides Moose with the ability to create custom type
857 |  |  |  |  | constraints to be used in attribute definition.
858 |  |  |  |  |
859 |  |  |  |  | =head2 Important Caveat
860 |  |  |  |  |
861 |  |  |  |  | This is B<NOT> a type system for Perl 5. These are type constraints,
862 |  |  |  |  | and they are not used by Moose unless you tell it to. No type
863 |  |  |  |  | inference is performed, expressions are not typed, etc. etc. etc.
864 |  |  |  |  |
865 |  |  |  |  | A type constraint is at heart a small "check if a value is valid"
866 |  |  |  |  | function. A constraint can be associated with an attribute. This
867 |  |  |  |  | simplifies parameter validation, and makes your code clearer to read,
868 |  |  |  |  | because you can refer to constraints by name.
869 |  |  |  |  |
870 |  |  |  |  | =head2 Slightly Less Important Caveat
871 |  |  |  |  |
872 |  |  |  |  | It is B<always> a good idea to quote your type names.
873 |  |  |  |  |
874 |  |  |  |  | This prevents Perl from trying to execute the call as an indirect
875 |  |  |  |  | object call. This can be an issue when you have a subtype with the
876 |  |  |  |  | same name as a valid class.
877 |  |  |  |  |
878 |  |  |  |  | For instance:
879 |  |  |  |  |
880 |  |  |  |  | subtype DateTime => as Object => where { $_->isa('DateTime') };
881 |  |  |  |  |
882 |  |  |  |  | will I<just work>, while this:
883 |  |  |  |  |
884 |  |  |  |  | use DateTime;
885 |  |  |  |  | subtype DateTime => as Object => where { $_->isa('DateTime') };
886 |  |  |  |  |
887 |  |  |  |  | will fail silently and cause many headaches. The simple way to solve
888 |  |  |  |  | this, as well as future proof your subtypes from classes which have
889 |  |  |  |  | yet 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 |  |  |  |  |
896 |  |  |  |  | This module also provides a simple hierarchy for Perl 5 types, here is
897 |  |  |  |  | that 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 |  |  |  |  |
921 |  |  |  |  | B<NOTE:> Any type followed by a type parameter C<[`a]> can be
922 |  |  |  |  | parameterized, 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 |  |  |  |  |
929 |  |  |  |  | If Moose finds a name in brackets that it does not recognize as an
930 |  |  |  |  | existing type, it assumes that this is a class name, for example
931 |  |  |  |  | C<ArrayRef[DateTime]>.
932 |  |  |  |  |
933 |  |  |  |  | B<NOTE:> Unless you parameterize a type, then it is invalid to include
934 |  |  |  |  | the square brackets. I.e. C<ArrayRef[]> will be treated as a new type
935 |  |  |  |  | name, I<not> as a parameterization of C<ArrayRef>.
936 |  |  |  |  |
937 |  |  |  |  | B<NOTE:> The C<Undef> type constraint for the most part works
938 |  |  |  |  | correctly now, but edge cases may still exist, please use it
939 |  |  |  |  | sparingly.
940 |  |  |  |  |
941 |  |  |  |  | B<NOTE:> The C<ClassName> type constraint does a complex package
942 |  |  |  |  | existence check. This means that your class B<must> be loaded for this
943 |  |  |  |  | type constraint to pass.
944 |  |  |  |  |
945 |  |  |  |  | B<NOTE:> The C<RoleName> constraint checks a string is a I<package
946 |  |  |  |  | name> which is a role, like C<'MyApp::Role::Comparable'>.
947 |  |  |  |  |
948 |  |  |  |  | =head2 Type Constraint Naming
949 |  |  |  |  |
950 |  |  |  |  | Type name declared via this module can only contain alphanumeric
951 |  |  |  |  | characters, colons (:), and periods (.).
952 |  |  |  |  |
953 |  |  |  |  | Since the types created by this module are global, it is suggested
954 |  |  |  |  | that you namespace your types just as you would namespace your
955 |  |  |  |  | modules. So instead of creating a I<Color> type for your
956 |  |  |  |  | B<My::Graphics> module, you would call the type
957 |  |  |  |  | I<My::Graphics::Types::Color> instead.
958 |  |  |  |  |
959 |  |  |  |  | =head2 Use with Other Constraint Modules
960 |  |  |  |  |
961 |  |  |  |  | This module can play nicely with other constraint modules with some
962 |  |  |  |  | slight tweaking. The C<where> clause in types is expected to be a
963 |  |  |  |  | C<CODE> reference which checks it's first argument and returns a
964 |  |  |  |  | boolean. Since most constraint modules work in a similar way, it
965 |  |  |  |  | should be simple to adapt them to work with Moose.
966 |  |  |  |  |
967 |  |  |  |  | For instance, this is how you could use it with
968 |  |  |  |  | L<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 |  |  |  |  |
978 |  |  |  |  | For more examples see the F<t/200_examples/004_example_w_DCS.t> test
979 |  |  |  |  | file.
980 |  |  |  |  |
981 |  |  |  |  | Here is an example of using L<Test::Deep> and it's non-test
982 |  |  |  |  | related 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 |  |  |  |  |
993 |  |  |  |  | For a complete example see the
994 |  |  |  |  | F<t/200_examples/005_example_w_TestDeep.t> test file.
995 |  |  |  |  |
996 |  |  |  |  | =head1 FUNCTIONS
997 |  |  |  |  |
998 |  |  |  |  | =head2 Type Constraint Constructors
999 |  |  |  |  |
1000 |  |  |  |  | The following functions are used to create type constraints. They
1001 |  |  |  |  | will also register the type constraints your create in a global
1002 |  |  |  |  | registry that is used to look types up by name.
1003 |  |  |  |  |
1004 |  |  |  |  | See 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 |  |  |  |  |
1010 |  |  |  |  | This creates a named subtype.
1011 |  |  |  |  |
1012 |  |  |  |  | If you provide a parent that Moose does not recognize, it will
1013 |  |  |  |  | automatically create a new class type constraint for this name.
1014 |  |  |  |  |
1015 |  |  |  |  | When creating a named type, the C<subtype> function should either be
1016 |  |  |  |  | called with the sugar helpers (C<where>, C<message>, etc), or with a
1017 |  |  |  |  | name and a hashref of parameters:
1018 |  |  |  |  |
1019 |  |  |  |  | subtype( 'Foo', { where => ..., message => ... } );
1020 |  |  |  |  |
1021 |  |  |  |  | The valid hashref keys are C<as> (the parent), C<where>, C<message>,
1022 |  |  |  |  | and C<optimize_as>.
1023 |  |  |  |  |
1024 |  |  |  |  | =item B<< subtype as 'Parent' => where { } ... >>
1025 |  |  |  |  |
1026 |  |  |  |  | This creates an unnamed subtype and will return the type
1027 |  |  |  |  | constraint meta-object, which will be an instance of
1028 |  |  |  |  | L<Moose::Meta::TypeConstraint>.
1029 |  |  |  |  |
1030 |  |  |  |  | When creating an anonymous type, the C<subtype> function should either
1031 |  |  |  |  | be called with the sugar helpers (C<where>, C<message>, etc), or with
1032 |  |  |  |  | just a hashref of parameters:
1033 |  |  |  |  |
1034 |  |  |  |  | subtype( { where => ..., message => ... } );
1035 |  |  |  |  |
1036 |  |  |  |  | =item B<class_type ($class, ?$options)>
1037 |  |  |  |  |
1038 |  |  |  |  | Creates a new subtype of C<Object> with the name C<$class> and the
1039 |  |  |  |  | metaclass L<Moose::Meta::TypeConstraint::Class>.
1040 |  |  |  |  |
1041 |  |  |  |  | =item B<role_type ($role, ?$options)>
1042 |  |  |  |  |
1043 |  |  |  |  | Creates a C<Role> type constraint with the name C<$role> and the
1044 |  |  |  |  | metaclass L<Moose::Meta::TypeConstraint::Role>.
1045 |  |  |  |  |
1046 |  |  |  |  | =item B<maybe_type ($type)>
1047 |  |  |  |  |
1048 |  |  |  |  | Creates a type constraint for either C<undef> or something of the
1049 |  |  |  |  | given type.
1050 |  |  |  |  |
1051 |  |  |  |  | =item B<duck_type ($name, \@methods)>
1052 |  |  |  |  |
1053 |  |  |  |  | This will create a subtype of Object and test to make sure the value
1054 |  |  |  |  | C<can()> do the methods in C<\@methods>.
1055 |  |  |  |  |
1056 |  |  |  |  | This is intended as an easy way to accept non-Moose objects that
1057 |  |  |  |  | provide a certain interface. If you're using Moose classes, we
1058 |  |  |  |  | recommend that you use a C<requires>-only Role instead.
1059 |  |  |  |  |
1060 |  |  |  |  | =item B<duck_type (\@methods)>
1061 |  |  |  |  |
1062 |  |  |  |  | If passed an ARRAY reference as the only parameter instead of the
1063 |  |  |  |  | C<$name>, C<\@methods> pair, this will create an unnamed duck type.
1064 |  |  |  |  | This 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 |  |  |  |  |
1073 |  |  |  |  | This will create a basic subtype for a given set of strings.
1074 |  |  |  |  | The resulting constraint will be a subtype of C<Str> and
1075 |  |  |  |  | will match any of the items in C<\@values>. It is case sensitive.
1076 |  |  |  |  | See the L<SYNOPSIS> for a simple example.
1077 |  |  |  |  |
1078 |  |  |  |  | B<NOTE:> This is not a true proper enum type, it is simply
1079 |  |  |  |  | a convenient constraint builder.
1080 |  |  |  |  |
1081 |  |  |  |  | =item B<enum (\@values)>
1082 |  |  |  |  |
1083 |  |  |  |  | If passed an ARRAY reference as the only parameter instead of the
1084 |  |  |  |  | C<$name>, C<\@values> pair, this will create an unnamed enum. This
1085 |  |  |  |  | can 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 |  |  |  |  |
1094 |  |  |  |  | This is just sugar for the type constraint construction syntax.
1095 |  |  |  |  |
1096 |  |  |  |  | It takes a single argument, which is the name of a parent type.
1097 |  |  |  |  |
1098 |  |  |  |  | =item B<where { ... }>
1099 |  |  |  |  |
1100 |  |  |  |  | This is just sugar for the type constraint construction syntax.
1101 |  |  |  |  |
1102 |  |  |  |  | It takes a subroutine reference as an argument. When the type
1103 |  |  |  |  | constraint is tested, the reference is run with the value to be tested
1104 |  |  |  |  | in C<$_>. This reference should return true or false to indicate
1105 |  |  |  |  | whether or not the constraint check passed.
1106 |  |  |  |  |
1107 |  |  |  |  | =item B<message { ... }>
1108 |  |  |  |  |
1109 |  |  |  |  | This is just sugar for the type constraint construction syntax.
1110 |  |  |  |  |
1111 |  |  |  |  | It takes a subroutine reference as an argument. When the type
1112 |  |  |  |  | constraint fails, then the code block is run with the value provided
1113 |  |  |  |  | in C<$_>. This reference should return a string, which will be used in
1114 |  |  |  |  | the text of the exception thrown.
1115 |  |  |  |  |
1116 |  |  |  |  | =item B<optimize_as { ... }>
1117 |  |  |  |  |
1118 |  |  |  |  | This can be used to define a "hand optimized" version of your
1119 |  |  |  |  | type constraint which can be used to avoid traversing a subtype
1120 |  |  |  |  | constraint hierarchy.
1121 |  |  |  |  |
1122 |  |  |  |  | B<NOTE:> You should only use this if you know what you are doing,
1123 |  |  |  |  | all the built in types use this, so your subtypes (assuming they
1124 |  |  |  |  | are shallow) will not likely need to use this.
1125 |  |  |  |  |
1126 |  |  |  |  | =item B<< type 'Name' => where { } ... >>
1127 |  |  |  |  |
1128 |  |  |  |  | This creates a base type, which has no parent.
1129 |  |  |  |  |
1130 |  |  |  |  | The 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
1132 |  |  |  |  | parameters:
1133 |  |  |  |  |
1134 |  |  |  |  | type( 'Foo', { where => ..., message => ... } );
1135 |  |  |  |  |
1136 |  |  |  |  | The 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 |  |  |  |  |
1146 |  |  |  |  | This is a utility function for doing simple type based dispatching similar to
1147 |  |  |  |  | match/case in OCaml and case/of in Haskell. It is not as featureful as those
1148 |  |  |  |  | languages, nor does not it support any kind of automatic destructuring
1149 |  |  |  |  | bind. Here is a simple Perl pretty printer dispatching over the core Moose
1150 |  |  |  |  | types.
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 |  |  |  |  |
1179 |  |  |  |  | Or 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 |  |  |  |  |
1204 |  |  |  |  | The matcher is done by mapping a C<$type> to an C<\&action>. The C<$type> can
1205 |  |  |  |  | be either a string type or a L<Moose::Meta::TypeConstraint> object, and
1206 |  |  |  |  | C<\&action> is a subroutine reference. This function will dispatch on the
1207 |  |  |  |  | first match for C<$value>. It is possible to have a catch-all by providing an
1208 |  |  |  |  | additional subroutine reference as the final argument to C<match_on_type>.
1209 |  |  |  |  |
1210 |  |  |  |  | =back
1211 |  |  |  |  |
1212 |  |  |  |  | =head2 Type Coercion Constructors
1213 |  |  |  |  |
1214 |  |  |  |  | You can define coercions for type constraints, which allow you to
1215 |  |  |  |  | automatically transform values to something valid for the type
1216 |  |  |  |  | constraint. If you ask your accessor to coerce, then Moose will run
1217 |  |  |  |  | the type-coercion code first, followed by the type constraint
1218 |  |  |  |  | check. This feature should be used carefully as it is very powerful
1219 |  |  |  |  | and could easily take off a limb if you are not careful.
1220 |  |  |  |  |
1221 |  |  |  |  | See 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 |  |  |  |  |
1227 |  |  |  |  | This defines a coercion from one type to another. The C<Name> argument
1228 |  |  |  |  | is the type you are coercing I<to>.
1229 |  |  |  |  |
1230 |  |  |  |  | =item B<from 'OtherName'>
1231 |  |  |  |  |
1232 |  |  |  |  | This is just sugar for the type coercion construction syntax.
1233 |  |  |  |  |
1234 |  |  |  |  | It takes a single type name (or type object), which is the type being
1235 |  |  |  |  | coerced I<from>.
1236 |  |  |  |  |
1237 |  |  |  |  | =item B<via { ... }>
1238 |  |  |  |  |
1239 |  |  |  |  | This is just sugar for the type coercion construction syntax.
1240 |  |  |  |  |
1241 |  |  |  |  | It takes a subroutine reference. This reference will be called with
1242 |  |  |  |  | the value to be coerced in C<$_>. It is expected to return a new value
1243 |  |  |  |  | of the proper type for the coercion.
1244 |  |  |  |  |
1245 |  |  |  |  | =back
1246 |  |  |  |  |
1247 |  |  |  |  | =head2 Creating and Finding Type Constraints
1248 |  |  |  |  |
1249 |  |  |  |  | These are additional functions for creating and finding type
1250 |  |  |  |  | constraints. Most of these functions are not available for
1251 |  |  |  |  | importing. The ones that are importable as specified.
1252 |  |  |  |  |
1253 |  |  |  |  | =over 4
1254 |  |  |  |  |
1255 |  |  |  |  | =item B<find_type_constraint($type_name)>
1256 |  |  |  |  |
1257 |  |  |  |  | This function can be used to locate the L<Moose::Meta::TypeConstraint>
1258 |  |  |  |  | object for a named type.
1259 |  |  |  |  |
1260 |  |  |  |  | This function is importable.
1261 |  |  |  |  |
1262 |  |  |  |  | =item B<register_type_constraint($type_object)>
1263 |  |  |  |  |
1264 |  |  |  |  | This function will register a L<Moose::Meta::TypeConstraint> with the
1265 |  |  |  |  | global type registry.
1266 |  |  |  |  |
1267 |  |  |  |  | This function is importable.
1268 |  |  |  |  |
1269 |  |  |  |  | =item B<normalize_type_constraint_name($type_constraint_name)>
1270 |  |  |  |  |
1271 |  |  |  |  | This method takes a type constraint name and returns the normalized
1272 |  |  |  |  | form. This removes any whitespace in the string.
1273 |  |  |  |  |
1274 |  |  |  |  | =item B<create_type_constraint_union($pipe_separated_types | @type_constraint_names)>
1275 |  |  |  |  |
1276 |  |  |  |  | This can take a union type specification like C<'Int|ArrayRef[Int]'>,
1277 |  |  |  |  | or a list of names. It returns a new
1278 |  |  |  |  | L<Moose::Meta::TypeConstraint::Union> object.
1279 |  |  |  |  |
1280 |  |  |  |  | =item B<create_parameterized_type_constraint($type_name)>
1281 |  |  |  |  |
1282 |  |  |  |  | Given a C<$type_name> in the form of C<'BaseType[ContainerType]'>,
1283 |  |  |  |  | this will create a new L<Moose::Meta::TypeConstraint::Parameterized>
1284 |  |  |  |  | object. The C<BaseType> must exist already exist as a parameterizable
1285 |  |  |  |  | type.
1286 |  |  |  |  |
1287 |  |  |  |  | =item B<create_class_type_constraint($class, $options)>
1288 |  |  |  |  |
1289 |  |  |  |  | Given a class name this function will create a new
1290 |  |  |  |  | L<Moose::Meta::TypeConstraint::Class> object for that class name.
1291 |  |  |  |  |
1292 |  |  |  |  | The C<$options> is a hash reference that will be passed to the
1293 |  |  |  |  | L<Moose::Meta::TypeConstraint::Class> constructor (as a hash).
1294 |  |  |  |  |
1295 |  |  |  |  | =item B<create_role_type_constraint($role, $options)>
1296 |  |  |  |  |
1297 |  |  |  |  | Given a role name this function will create a new
1298 |  |  |  |  | L<Moose::Meta::TypeConstraint::Role> object for that role name.
1299 |  |  |  |  |
1300 |  |  |  |  | The C<$options> is a hash reference that will be passed to the
1301 |  |  |  |  | L<Moose::Meta::TypeConstraint::Role> constructor (as a hash).
1302 |  |  |  |  |
1303 |  |  |  |  | =item B<create_enum_type_constraint($name, $values)>
1304 |  |  |  |  |
1305 |  |  |  |  | Given a enum name this function will create a new
1306 |  |  |  |  | L<Moose::Meta::TypeConstraint::Enum> object for that enum name.
1307 |  |  |  |  |
1308 |  |  |  |  | =item B<create_duck_type_constraint($name, $methods)>
1309 |  |  |  |  |
1310 |  |  |  |  | Given a duck type name this function will create a new
1311 |  |  |  |  | L<Moose::Meta::TypeConstraint::DuckType> object for that enum name.
1312 |  |  |  |  |
1313 |  |  |  |  | =item B<find_or_parse_type_constraint($type_name)>
1314 |  |  |  |  |
1315 |  |  |  |  | Given a type name, this first attempts to find a matching constraint
1316 |  |  |  |  | in the global registry.
1317 |  |  |  |  |
1318 |  |  |  |  | If the type name is a union or parameterized type, it will create a
1319 |  |  |  |  | new object of the appropriate, but if given a "regular" type that does
1320 |  |  |  |  | not yet exist, it simply returns false.
1321 |  |  |  |  |
1322 |  |  |  |  | When given a union or parameterized type, the member or base type must
1323 |  |  |  |  | already exist.
1324 |  |  |  |  |
1325 |  |  |  |  | If it creates a new union or parameterized type, it will add it to the
1326 |  |  |  |  | global 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 |  |  |  |  |
1332 |  |  |  |  | These functions will first call C<find_or_parse_type_constraint>. If
1333 |  |  |  |  | that function does not return a type, a new anonymous type object will
1334 |  |  |  |  | be created.
1335 |  |  |  |  |
1336 |  |  |  |  | The C<isa> variant will use C<create_class_type_constraint> and the
1337 |  |  |  |  | C<does> variant will use C<create_role_type_constraint>.
1338 |  |  |  |  |
1339 |  |  |  |  | =item B<get_type_constraint_registry>
1340 |  |  |  |  |
1341 |  |  |  |  | Returns the L<Moose::Meta::TypeConstraint::Registry> object which
1342 |  |  |  |  | keeps track of all type constraints.
1343 |  |  |  |  |
1344 |  |  |  |  | =item B<list_all_type_constraints>
1345 |  |  |  |  |
1346 |  |  |  |  | This will return a list of type constraint names in the global
1347 |  |  |  |  | registry. You can then fetch the actual type object using
1348 |  |  |  |  | C<find_type_constraint($type_name)>.
1349 |  |  |  |  |
1350 |  |  |  |  | =item B<list_all_builtin_type_constraints>
1351 |  |  |  |  |
1352 |  |  |  |  | This will return a list of builtin type constraints, meaning those
1353 |  |  |  |  | which are defined in this module. See the L<Default Type Constraints>
1354 |  |  |  |  | section for a complete list.
1355 |  |  |  |  |
1356 |  |  |  |  | =item B<export_type_constraints_as_functions>
1357 |  |  |  |  |
1358 |  |  |  |  | This will export all the current type constraints as functions into
1359 |  |  |  |  | the caller's namespace (C<Int()>, C<Str()>, etc). Right now, this is
1360 |  |  |  |  | mostly used for testing, but it might prove useful to others.
1361 |  |  |  |  |
1362 |  |  |  |  | =item B<get_all_parameterizable_types>
1363 |  |  |  |  |
1364 |  |  |  |  | This returns all the parameterizable types that have been registered,
1365 |  |  |  |  | as a list of type objects.
1366 |  |  |  |  |
1367 |  |  |  |  | =item B<add_parameterizable_type($type)>
1368 |  |  |  |  |
1369 |  |  |  |  | Adds C<$type> to the list of parameterizable types
1370 |  |  |  |  |
1371 |  |  |  |  | =back
1372 |  |  |  |  |
1373 |  |  |  |  | =head1 BUGS
1374 |  |  |  |  |
1375 |  |  |  |  | See L<Moose/BUGS> for details on reporting bugs.
1376 |  |  |  |  |
1377 |  |  |  |  | =head1 AUTHOR
1378 |  |  |  |  |
1379 |  |  |  |  | Stevan Little E<lt>stevan@iinteractive.comE<gt>
1380 |  |  |  |  |
1381 |  |  |  |  | =head1 COPYRIGHT AND LICENSE
1382 |  |  |  |  |
1383 |  |  |  |  | Copyright 2006-2010 by Infinity Interactive, Inc.
1384 |  |  |  |  |
1385 |  |  |  |  | L<http://www.iinteractive.com>
1386 |  |  |  |  |
1387 |  |  |  |  | This library is free software; you can redistribute it and/or modify
1388 |  |  |  |  | it under the same terms as Perl itself.
1389 |  |  |  |  |
1390 |  |  |  |  | =cut
|  |  |  |  | # spent 281µs (159+122) within Moose::Util::TypeConstraints::CORE:match which was called 45 times, avg 6µs/call: # 29 times (91µs+122µs) by Moose::Util::TypeConstraints::_create_type_constraint at line 508 of Moose/Util/TypeConstraints.pm, avg 7µs/call # 6 times (21µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 620 of Moose/Util/TypeConstraints.pm, avg 4µs/call # 4 times (25µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 599 of Moose/Util/TypeConstraints.pm, avg 6µs/call # 3 times (16µs+0s) by Moose::Util::TypeConstraints::_parse_parameterized_type_constraint at line 593 of Moose/Util/TypeConstraints.pm, avg 5µs/call # 2 times (4µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 607 of Moose/Util/TypeConstraints.pm, avg 2µs/call # once (3µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 606 of Moose/Util/TypeConstraints.pm sub Moose::Util::TypeConstraints::CORE:match; # xsub
|  |  |  |  | # spent 15µs within Moose::Util::TypeConstraints::CORE:qr which was called 9 times, avg 2µs/call: # once (5µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 574 of Moose/Util/TypeConstraints.pm # once (2µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 583 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 580 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 589 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 587 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 581 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 586 of Moose/Util/TypeConstraints.pm # once (1µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 575 of Moose/Util/TypeConstraints.pm # once (900ns+0s) by Moose::Meta::Attribute::BEGIN@18 at line 576 of Moose/Util/TypeConstraints.pm sub Moose::Util::TypeConstraints::CORE:qr; # xsub
|  |  |  |  | # spent 452µs within Moose::Util::TypeConstraints::CORE:regcomp which was called 23 times, avg 20µs/call: # 6 times (87µs+0s) by Moose::Util::TypeConstraints::_detect_type_constraint_union at line 620 of Moose/Util/TypeConstraints.pm, avg 15µs/call # 4 times (34µs+0s) by Moose::Util::TypeConstraints::_detect_parameterized_type_constraint at line 599 of Moose/Util/TypeConstraints.pm, avg 9µs/call # 3 times (28µs+0s) by Moose::Util::TypeConstraints::_parse_parameterized_type_constraint at line 593 of Moose/Util/TypeConstraints.pm, avg 9µs/call # 2 times (1µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 607 of Moose/Util/TypeConstraints.pm, avg 650ns/call # once (68µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 589 of Moose/Util/TypeConstraints.pm # once (58µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 587 of Moose/Util/TypeConstraints.pm # once (56µs+0s) by Moose::Util::TypeConstraints::_parse_type_constraint_union at line 606 of Moose/Util/TypeConstraints.pm # once (36µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 583 of Moose/Util/TypeConstraints.pm # once (31µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 580 of Moose/Util/TypeConstraints.pm # once (30µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 581 of Moose/Util/TypeConstraints.pm # once (13µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 575 of Moose/Util/TypeConstraints.pm # once (8µs+0s) by Moose::Meta::Attribute::BEGIN@18 at line 586 of Moose/Util/TypeConstraints.pm sub Moose::Util::TypeConstraints::CORE:regcomp; # xsub
|  |  |  |  | # spent 144µs (93+51) within Moose::Util::TypeConstraints::CORE:subst which was called 95 times, avg 2µs/call: # 95 times (93µs+51µs) by Moose::Util::TypeConstraints::normalize_type_constraint_name at line 237 of Moose/Util/TypeConstraints.pm, avg 2µs/call sub Moose::Util::TypeConstraints::CORE:subst; # xsub