2 package Moose::Util::TypeConstraints;
8 use Scalar::Util 'blessed';
11 our $VERSION = '0.56';
12 our $AUTHORITY = 'cpan:STEVAN';
14 ## --------------------------------------------------------
15 # Prototyped subs must be predeclared because we have a
16 # circular dependency with Moose::Meta::Attribute et. al.
17 # so in case of us being use'd first the predeclaration
18 # ensures the prototypes are in scope when consumers are
21 # creation and location
22 sub find_type_constraint ($);
23 sub register_type_constraint ($);
24 sub find_or_create_type_constraint ($;$);
25 sub find_or_parse_type_constraint ($);
26 sub find_or_create_isa_type_constraint ($);
27 sub find_or_create_does_type_constraint ($);
28 sub create_type_constraint_union (@);
29 sub create_parameterized_type_constraint ($);
30 sub create_class_type_constraint ($;$);
31 sub create_role_type_constraint ($;$);
32 sub create_enum_type_constraint ($$);
48 sub _create_type_constraint ($$$;$$);
49 sub _install_type_coercions ($$);
51 ## --------------------------------------------------------
53 use Moose::Meta::TypeConstraint;
54 use Moose::Meta::TypeConstraint::Union;
55 use Moose::Meta::TypeConstraint::Parameterized;
56 use Moose::Meta::TypeConstraint::Parameterizable;
57 use Moose::Meta::TypeConstraint::Class;
58 use Moose::Meta::TypeConstraint::Role;
59 use Moose::Meta::TypeConstraint::Enum;
60 use Moose::Meta::TypeCoercion;
61 use Moose::Meta::TypeCoercion::Union;
62 use Moose::Meta::TypeConstraint::Registry;
63 use Moose::Util::TypeConstraints::OptimizedConstraints;
65 Moose::Exporter->setup_import_methods(
68 type subtype class_type role_type as where message optimize_as
72 register_type_constraint )
77 ## --------------------------------------------------------
78 ## type registry and some useful functions for it
79 ## --------------------------------------------------------
81 my $REGISTRY = Moose::Meta::TypeConstraint::Registry->new;
83 sub get_type_constraint_registry { $REGISTRY }
84 sub list_all_type_constraints { keys %{$REGISTRY->type_constraints} }
85 sub export_type_constraints_as_functions {
88 foreach my $constraint (keys %{$REGISTRY->type_constraints}) {
89 my $tc = $REGISTRY->get_type_constraint($constraint)->_compiled_type_constraint;
90 *{"${pkg}::${constraint}"} = sub { $tc->($_[0]) ? 1 : undef }; # the undef is for compat
94 sub create_type_constraint_union (@) {
95 my @type_constraint_names;
97 if (scalar @_ == 1 && _detect_type_constraint_union($_[0])) {
98 @type_constraint_names = _parse_type_constraint_union($_[0]);
101 @type_constraint_names = @_;
104 (scalar @type_constraint_names >= 2)
105 || confess "You must pass in at least 2 type names to make a union";
107 ($REGISTRY->has_type_constraint($_))
108 || confess "Could not locate type constraint ($_) for the union"
109 foreach @type_constraint_names;
111 return Moose::Meta::TypeConstraint::Union->new(
112 type_constraints => [
114 $REGISTRY->get_type_constraint($_)
115 } @type_constraint_names
120 sub create_parameterized_type_constraint ($) {
121 my $type_constraint_name = shift;
123 my ($base_type, $type_parameter) = _parse_parameterized_type_constraint($type_constraint_name);
125 (defined $base_type && defined $type_parameter)
126 || confess "Could not parse type name ($type_constraint_name) correctly";
128 ($REGISTRY->has_type_constraint($base_type))
129 || confess "Could not locate the base type ($base_type)";
131 return Moose::Meta::TypeConstraint::Parameterized->new(
132 name => $type_constraint_name,
133 parent => $REGISTRY->get_type_constraint($base_type),
134 type_parameter => find_or_create_isa_type_constraint($type_parameter),
138 #should we also support optimized checks?
139 sub create_class_type_constraint ($;$) {
140 my ( $class, $options ) = @_;
142 # too early for this check
143 #find_type_constraint("ClassName")->check($class)
144 # || confess "Can't create a class type constraint because '$class' is not a class name";
152 $options{name} ||= "__ANON__";
154 Moose::Meta::TypeConstraint::Class->new( %options );
157 sub create_role_type_constraint ($;$) {
158 my ( $role, $options ) = @_;
160 # too early for this check
161 #find_type_constraint("ClassName")->check($class)
162 # || confess "Can't create a class type constraint because '$class' is not a class name";
170 $options{name} ||= "__ANON__";
172 Moose::Meta::TypeConstraint::Role->new( %options );
176 sub find_or_create_type_constraint ($;$) {
177 my ( $type_constraint_name, $options_for_anon_type ) = @_;
179 if ( my $constraint = find_or_parse_type_constraint($type_constraint_name) ) {
182 elsif ( defined $options_for_anon_type ) {
184 # if there is no $options_for_anon_type
185 # specified, then we assume they don't
186 # want to create one, and return nothing.
188 # otherwise assume that we should create
189 # an ANON type with the $options_for_anon_type
190 # options which can be passed in. It should
191 # be noted that these don't get registered
192 # so we need to return it.
194 return Moose::Meta::TypeConstraint->new(
196 %{$options_for_anon_type}
203 sub find_or_create_isa_type_constraint ($) {
204 my $type_constraint_name = shift;
205 find_or_parse_type_constraint($type_constraint_name) || create_class_type_constraint($type_constraint_name)
208 sub find_or_create_does_type_constraint ($) {
209 my $type_constraint_name = shift;
210 find_or_parse_type_constraint($type_constraint_name) || create_role_type_constraint($type_constraint_name)
213 sub find_or_parse_type_constraint ($) {
214 my $type_constraint_name = shift;
216 return $REGISTRY->get_type_constraint($type_constraint_name)
217 if $REGISTRY->has_type_constraint($type_constraint_name);
221 if (_detect_type_constraint_union($type_constraint_name)) {
222 $constraint = create_type_constraint_union($type_constraint_name);
224 elsif (_detect_parameterized_type_constraint($type_constraint_name)) {
225 $constraint = create_parameterized_type_constraint($type_constraint_name);
230 $REGISTRY->add_type_constraint($constraint);
234 ## --------------------------------------------------------
235 ## exported functions ...
236 ## --------------------------------------------------------
238 sub find_type_constraint ($) {
241 if ( blessed $type and $type->isa("Moose::Meta::TypeConstraint") ) {
244 return $REGISTRY->get_type_constraint($type);
248 sub register_type_constraint ($) {
249 my $constraint = shift;
250 confess "can't register an unnamed type constraint" unless defined $constraint->name;
251 $REGISTRY->add_type_constraint($constraint);
258 splice(@_, 1, 0, undef);
259 goto &_create_type_constraint;
262 sub subtype ($$;$$$) {
264 # this adds an undef for the name
265 # if this is an anon-subtype:
266 # subtype(Num => where { $_ % 2 == 0 }) # anon 'even' subtype
267 # but if the last arg is not a code
268 # ref then it is a subtype alias:
269 # subtype(MyNumbers => as Num); # now MyNumbers is the same as Num
270 # ... yeah I know it's ugly code
272 unshift @_ => undef if scalar @_ <= 2 && ('CODE' eq ref($_[1]));
273 goto &_create_type_constraint;
276 sub class_type ($;$) {
277 register_type_constraint(
278 create_class_type_constraint(
280 ( defined($_[1]) ? $_[1] : () ),
285 sub role_type ($;$) {
286 register_type_constraint(
287 create_role_type_constraint(
289 ( defined($_[1]) ? $_[1] : () ),
295 my ($type_name, @coercion_map) = @_;
296 _install_type_coercions($type_name, \@coercion_map);
300 sub from ($) { $_[0] }
301 sub where (&) { $_[0] }
302 sub via (&) { $_[0] }
304 sub message (&) { +{ message => $_[0] } }
305 sub optimize_as (&) { +{ optimized => $_[0] } }
308 my ($type_name, @values) = @_;
310 # if only an array-ref is passed then
311 # you get an anon-enum
313 if (ref $type_name eq 'ARRAY' && !@values) {
314 @values = @$type_name;
317 (scalar @values >= 2)
318 || confess "You must have at least two values to enumerate through";
319 my %valid = map { $_ => 1 } @values;
321 register_type_constraint(
322 create_enum_type_constraint(
329 sub create_enum_type_constraint ($$) {
330 my ( $type_name, $values ) = @_;
332 Moose::Meta::TypeConstraint::Enum->new(
333 name => $type_name || '__ANON__',
338 ## --------------------------------------------------------
339 ## desugaring functions ...
340 ## --------------------------------------------------------
342 sub _create_type_constraint ($$$;$$) {
347 my ($message, $optimized);
349 $message = $_->{message} if exists $_->{message};
350 $optimized = $_->{optimized} if exists $_->{optimized};
353 my $pkg_defined_in = scalar(caller(0));
356 my $type = $REGISTRY->get_type_constraint($name);
358 ($type->_package_defined_in eq $pkg_defined_in)
359 || confess ("The type constraint '$name' has already been created in "
360 . $type->_package_defined_in . " and cannot be created again in "
365 my $class = "Moose::Meta::TypeConstraint";
367 # FIXME should probably not be a special case
368 if ( defined $parent and $parent = find_or_parse_type_constraint($parent) ) {
369 $class = "Moose::Meta::TypeConstraint::Parameterizable"
370 if $parent->isa("Moose::Meta::TypeConstraint::Parameterizable");
373 my $constraint = $class->new(
374 name => $name || '__ANON__',
375 package_defined_in => $pkg_defined_in,
377 ($parent ? (parent => $parent ) : ()),
378 ($check ? (constraint => $check) : ()),
379 ($message ? (message => $message) : ()),
380 ($optimized ? (optimized => $optimized) : ()),
384 # if we have a type constraint union, and no
385 # type check, this means we are just aliasing
386 # the union constraint, which means we need to
387 # handle this differently.
389 if (not(defined $check)
390 && $parent->isa('Moose::Meta::TypeConstraint::Union')
391 && $parent->has_coercion
393 $constraint->coercion(Moose::Meta::TypeCoercion::Union->new(
394 type_constraint => $parent
398 $REGISTRY->add_type_constraint($constraint)
404 sub _install_type_coercions ($$) {
405 my ($type_name, $coercion_map) = @_;
406 my $type = find_type_constraint($type_name);
408 || confess "Cannot find type '$type_name', perhaps you forgot to load it.";
409 if ($type->has_coercion) {
410 $type->coercion->add_type_coercions(@$coercion_map);
413 my $type_coercion = Moose::Meta::TypeCoercion->new(
414 type_coercion_map => $coercion_map,
415 type_constraint => $type
417 $type->coercion($type_coercion);
421 ## --------------------------------------------------------
422 ## type notation parsing ...
423 ## --------------------------------------------------------
426 # All I have to say is mugwump++ cause I know
427 # do not even have enough regexp-fu to be able
428 # to have written this (I can only barely
429 # understand it as it is)
434 my $valid_chars = qr{[\w:]};
435 my $type_atom = qr{ $valid_chars+ };
439 my $type = qr{ $valid_chars+ (?: \[ (??{$any}) \] )? }x;
440 my $type_capture_parts = qr{ ($valid_chars+) (?: \[ ((??{$any})) \] )? }x;
441 my $type_with_parameter = qr{ $valid_chars+ \[ (??{$any}) \] }x;
443 my $op_union = qr{ \s* \| \s* }x;
444 my $union = qr{ $type (?: $op_union $type )+ }x;
446 $any = qr{ $type | $union }x;
448 sub _parse_parameterized_type_constraint {
449 { no warnings 'void'; $any; } # force capture of interpolated lexical
450 $_[0] =~ m{ $type_capture_parts }x;
454 sub _detect_parameterized_type_constraint {
455 { no warnings 'void'; $any; } # force capture of interpolated lexical
456 $_[0] =~ m{ ^ $type_with_parameter $ }x;
459 sub _parse_type_constraint_union {
460 { no warnings 'void'; $any; } # force capture of interpolated lexical
463 while ( $given =~ m{ \G (?: $op_union )? ($type) }gcx ) {
466 (pos($given) eq length($given))
467 || confess "'$given' didn't parse (parse-pos="
475 sub _detect_type_constraint_union {
476 { no warnings 'void'; $any; } # force capture of interpolated lexical
477 $_[0] =~ m{^ $type $op_union $type ( $op_union .* )? $}x;
481 ## --------------------------------------------------------
482 # define some basic built-in types
483 ## --------------------------------------------------------
485 type 'Any' => where { 1 }; # meta-type including all
486 type 'Item' => where { 1 }; # base-type
488 subtype 'Undef' => as 'Item' => where { !defined($_) };
489 subtype 'Defined' => as 'Item' => where { defined($_) };
493 => where { !defined($_) || $_ eq "" || "$_" eq '1' || "$_" eq '0' };
497 => where { !ref($_) }
498 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Value;
503 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Ref;
508 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Str;
512 => where { Scalar::Util::looks_like_number($_) }
513 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Num;
517 => where { "$_" =~ /^-?[0-9]+$/ }
518 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Int;
520 subtype 'ScalarRef' => as 'Ref' => where { ref($_) eq 'SCALAR' } => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::ScalarRef;
521 subtype 'CodeRef' => as 'Ref' => where { ref($_) eq 'CODE' } => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::CodeRef;
522 subtype 'RegexpRef' => as 'Ref' => where { ref($_) eq 'Regexp' } => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::RegexpRef;
523 subtype 'GlobRef' => as 'Ref' => where { ref($_) eq 'GLOB' } => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::GlobRef;
526 # scalar filehandles are GLOB refs,
527 # but a GLOB ref is not always a filehandle
530 => where { Scalar::Util::openhandle($_) || ( blessed($_) && $_->isa("IO::Handle") ) }
531 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::FileHandle;
534 # blessed(qr/.../) returns true,.. how odd
537 => where { blessed($_) && blessed($_) ne 'Regexp' }
538 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Object;
542 => where { $_->can('does') }
543 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::Role;
545 my $_class_name_checker = sub {
550 => where { Class::MOP::is_class_loaded($_) }
551 => optimize_as \&Moose::Util::TypeConstraints::OptimizedConstraints::ClassName;
553 ## --------------------------------------------------------
554 # parameterizable types ...
556 $REGISTRY->add_type_constraint(
557 Moose::Meta::TypeConstraint::Parameterizable->new(
559 package_defined_in => __PACKAGE__,
560 parent => find_type_constraint('Ref'),
561 constraint => sub { ref($_) eq 'ARRAY' },
562 optimized => \&Moose::Util::TypeConstraints::OptimizedConstraints::ArrayRef,
563 constraint_generator => sub {
564 my $type_parameter = shift;
565 my $check = $type_parameter->_compiled_type_constraint;
567 foreach my $x (@$_) {
568 ($check->($x)) || return
575 $REGISTRY->add_type_constraint(
576 Moose::Meta::TypeConstraint::Parameterizable->new(
578 package_defined_in => __PACKAGE__,
579 parent => find_type_constraint('Ref'),
580 constraint => sub { ref($_) eq 'HASH' },
581 optimized => \&Moose::Util::TypeConstraints::OptimizedConstraints::HashRef,
582 constraint_generator => sub {
583 my $type_parameter = shift;
584 my $check = $type_parameter->_compiled_type_constraint;
586 foreach my $x (values %$_) {
587 ($check->($x)) || return
594 $REGISTRY->add_type_constraint(
595 Moose::Meta::TypeConstraint::Parameterizable->new(
597 package_defined_in => __PACKAGE__,
598 parent => find_type_constraint('Item'),
599 constraint => sub { 1 },
600 constraint_generator => sub {
601 my $type_parameter = shift;
602 my $check = $type_parameter->_compiled_type_constraint;
604 return 1 if not(defined($_)) || $check->($_);
611 my @PARAMETERIZABLE_TYPES = map {
612 $REGISTRY->get_type_constraint($_)
613 } qw[ArrayRef HashRef Maybe];
615 sub get_all_parameterizable_types { @PARAMETERIZABLE_TYPES }
616 sub add_parameterizable_type {
618 (blessed $type && $type->isa('Moose::Meta::TypeConstraint::Parameterizable'))
619 || confess "Type must be a Moose::Meta::TypeConstraint::Parameterizable not $type";
620 push @PARAMETERIZABLE_TYPES => $type;
623 ## --------------------------------------------------------
624 # end of built-in types ...
625 ## --------------------------------------------------------
628 my @BUILTINS = list_all_type_constraints();
629 sub list_all_builtin_type_constraints { @BUILTINS }
640 Moose::Util::TypeConstraints - Type constraint system for Moose
644 use Moose::Util::TypeConstraints;
646 type 'Num' => where { Scalar::Util::looks_like_number($_) };
652 subtype 'NaturalLessThanTen'
655 => message { "This number ($_) is not less than ten!" };
661 enum 'RGBColors' => qw(red green blue);
665 This module provides Moose with the ability to create custom type
666 contraints to be used in attribute definition.
668 =head2 Important Caveat
670 This is B<NOT> a type system for Perl 5. These are type constraints,
671 and they are not used by Moose unless you tell it to. No type
672 inference is performed, expression are not typed, etc. etc. etc.
674 This is simply a means of creating small constraint functions which
675 can be used to simplify your own type-checking code, with the added
676 side benefit of making your intentions clearer through self-documentation.
678 =head2 Slightly Less Important Caveat
680 It is B<always> a good idea to quote your type and subtype names.
682 This is to prevent perl from trying to execute the call as an indirect
683 object call. This issue only seems to come up when you have a subtype
684 the same name as a valid class, but when the issue does arise it tends
685 to be quite annoying to debug.
687 So for instance, this:
689 subtype DateTime => as Object => where { $_->isa('DateTime') };
691 will I<Just Work>, while this:
694 subtype DateTime => as Object => where { $_->isa('DateTime') };
696 will fail silently and cause many headaches. The simple way to solve
697 this, as well as future proof your subtypes from classes which have
698 yet to have been created yet, is to simply do this:
701 subtype 'DateTime' => as 'Object' => where { $_->isa('DateTime') };
703 =head2 Default Type Constraints
705 This module also provides a simple hierarchy for Perl 5 types, here is
706 that hierarchy represented visually.
730 B<NOTE:> Any type followed by a type parameter C<[`a]> can be
731 parameterized, this means you can say:
733 ArrayRef[Int] # an array of intergers
734 HashRef[CodeRef] # a hash of str to CODE ref mappings
735 Maybe[Str] # value may be a string, may be undefined
737 B<NOTE:> The C<Undef> type constraint for the most part works
738 correctly now, but edge cases may still exist, please use it
741 B<NOTE:> The C<ClassName> type constraint does a complex package
742 existence check. This means that your class B<must> be loaded for
743 this type constraint to pass. I know this is not ideal for all,
744 but it is a saner restriction than most others.
746 =head2 Type Constraint Naming
748 Since the types created by this module are global, it is suggested
749 that you namespace your types just as you would namespace your
750 modules. So instead of creating a I<Color> type for your B<My::Graphics>
751 module, you would call the type I<My::Graphics::Color> instead.
753 =head2 Use with Other Constraint Modules
755 This module should play fairly nicely with other constraint
756 modules with only some slight tweaking. The C<where> clause
757 in types is expected to be a C<CODE> reference which checks
758 it's first argument and returns a boolean. Since most constraint
759 modules work in a similar way, it should be simple to adapt
760 them to work with Moose.
762 For instance, this is how you could use it with
763 L<Declare::Constraints::Simple> to declare a completely new type.
765 type 'HashOfArrayOfObjects'
768 -values => IsArrayRef( IsObject ));
770 For more examples see the F<t/200_examples/204_example_w_DCS.t>
773 Here is an example of using L<Test::Deep> and it's non-test
774 related C<eq_deeply> function.
776 type 'ArrayOfHashOfBarsAndRandomNumbers'
779 array_each(subhashof({
781 random_number => ignore()
785 For a complete example see the
786 F<t/200_examples/205_example_w_TestDeep.t> test file.
790 =head2 Type Constraint Constructors
792 The following functions are used to create type constraints.
793 They will then register the type constraints in a global store
794 where Moose can get to them if it needs to.
796 See the L<SYNOPSIS> for an example of how to use these.
800 =item B<type ($name, $where_clause)>
802 This creates a base type, which has no parent.
804 =item B<subtype ($name, $parent, $where_clause, ?$message)>
806 This creates a named subtype.
808 =item B<subtype ($parent, $where_clause, ?$message)>
810 This creates an unnamed subtype and will return the type
811 constraint meta-object, which will be an instance of
812 L<Moose::Meta::TypeConstraint>.
814 =item B<class_type ($class, ?$options)>
816 Creates a type constraint with the name C<$class> and the metaclass
817 L<Moose::Meta::TypeConstraint::Class>.
819 =item B<role_type ($role, ?$options)>
821 Creates a type constraint with the name C<$role> and the metaclass
822 L<Moose::Meta::TypeConstraint::Role>.
824 =item B<enum ($name, @values)>
826 This will create a basic subtype for a given set of strings.
827 The resulting constraint will be a subtype of C<Str> and
828 will match any of the items in C<@values>. It is case sensitive.
829 See the L<SYNOPSIS> for a simple example.
831 B<NOTE:> This is not a true proper enum type, it is simple
832 a convient constraint builder.
834 =item B<enum (\@values)>
836 If passed an ARRAY reference instead of the C<$name>, C<@values> pair,
837 this will create an unnamed enum. This can then be used in an attribute
840 has 'sort_order' => (
842 isa => enum([qw[ ascending descending ]]),
847 This is just sugar for the type constraint construction syntax.
851 This is just sugar for the type constraint construction syntax.
855 This is just sugar for the type constraint construction syntax.
859 This can be used to define a "hand optimized" version of your
860 type constraint which can be used to avoid traversing a subtype
861 constraint heirarchy.
863 B<NOTE:> You should only use this if you know what you are doing,
864 all the built in types use this, so your subtypes (assuming they
865 are shallow) will not likely need to use this.
869 =head2 Type Coercion Constructors
871 Type constraints can also contain type coercions as well. If you
872 ask your accessor to coerce, then Moose will run the type-coercion
873 code first, followed by the type constraint check. This feature
874 should be used carefully as it is very powerful and could easily
875 take off a limb if you are not careful.
877 See the L<SYNOPSIS> for an example of how to use these.
885 This is just sugar for the type coercion construction syntax.
889 This is just sugar for the type coercion construction syntax.
893 =head2 Type Constraint Construction & Locating
897 =item B<create_type_constraint_union ($pipe_seperated_types | @type_constraint_names)>
899 Given string with C<$pipe_seperated_types> or a list of C<@type_constraint_names>,
900 this will return a L<Moose::Meta::TypeConstraint::Union> instance.
902 =item B<create_parameterized_type_constraint ($type_name)>
904 Given a C<$type_name> in the form of:
906 BaseType[ContainerType]
908 this will extract the base type and container type and build an instance of
909 L<Moose::Meta::TypeConstraint::Parameterized> for it.
911 =item B<create_class_type_constraint ($class, ?$options)>
913 Given a class name it will create a new L<Moose::Meta::TypeConstraint::Class>
914 object for that class name.
916 =item B<create_role_type_constraint ($role, ?$options)>
918 Given a role name it will create a new L<Moose::Meta::TypeConstraint::Role>
919 object for that role name.
921 =item B<create_enum_type_constraint ($name, $values)>
923 =item B<find_or_parse_type_constraint ($type_name)>
925 This will attempt to find or create a type constraint given the a C<$type_name>.
926 If it cannot find it in the registry, it will see if it should be a union or
927 container type an create one if appropriate
929 =item B<find_or_create_type_constraint ($type_name, ?$options_for_anon_type)>
931 This function will first call C<find_or_parse_type_constraint> with the type name.
933 If no type is found or created, but C<$options_for_anon_type> are provided, it
934 will create the corresponding type.
936 This was used by the C<does> and C<isa> parameters to L<Moose::Meta::Attribute>
937 and are now superseded by C<find_or_create_isa_type_constraint> and
938 C<find_or_create_does_type_constraint>.
940 =item B<find_or_create_isa_type_constraint ($type_name)>
942 =item B<find_or_create_does_type_constraint ($type_name)>
944 Attempts to parse the type name using L<find_or_parse_type_constraint> and if
945 no appropriate constraint is found will create a new anonymous one.
947 The C<isa> variant will use C<create_class_type_constraint> and the C<does>
948 variant will use C<create_role_type_constraint>.
950 =item B<find_type_constraint ($type_name)>
952 This function can be used to locate a specific type constraint
953 meta-object, of the class L<Moose::Meta::TypeConstraint> or a
954 derivative. What you do with it from there is up to you :)
956 =item B<register_type_constraint ($type_object)>
958 This function will register a named type constraint with the type registry.
960 =item B<get_type_constraint_registry>
962 Fetch the L<Moose::Meta::TypeConstraint::Registry> object which
963 keeps track of all type constraints.
965 =item B<list_all_type_constraints>
967 This will return a list of type constraint names, you can then
968 fetch them using C<find_type_constraint ($type_name)> if you
971 =item B<list_all_builtin_type_constraints>
973 This will return a list of builtin type constraints, meaning,
974 those which are defined in this module. See the section
975 labeled L<Default Type Constraints> for a complete list.
977 =item B<export_type_constraints_as_functions>
979 This will export all the current type constraints as functions
980 into the caller's namespace. Right now, this is mostly used for
981 testing, but it might prove useful to others.
983 =item B<get_all_parameterizable_types>
985 This returns all the parameterizable types that have been registered.
987 =item B<add_parameterizable_type ($type)>
989 Adds C<$type> to the list of parameterizable types
993 =head2 Namespace Management
999 This will remove all the type constraint keywords from the
1000 calling class namespace.
1006 All complex software has bugs lurking in it, and this module is no
1007 exception. If you find a bug please either email me, or add the bug
1012 Stevan Little E<lt>stevan@iinteractive.comE<gt>
1014 =head1 COPYRIGHT AND LICENSE
1016 Copyright 2006-2008 by Infinity Interactive, Inc.
1018 L<http://www.iinteractive.com>
1020 This library is free software; you can redistribute it and/or modify
1021 it under the same terms as Perl itself.