=cut
-#use warnings;
-#use strict;
-
use Moose::Util::TypeConstraints;
use MooseX::Types::TypeDecorator;
-use MooseX::Types::Base ();
-use MooseX::Types::Util qw( filter_tags );
+use MooseX::Types::Base ();
+use MooseX::Types::Util qw( filter_tags );
use MooseX::Types::UndefinedType;
-use Carp::Clan qw( ^MooseX::Types );
+use MooseX::Types::CheckedUtilExports ();
+use Carp::Clan qw( ^MooseX::Types );
+use Sub::Name;
+use Scalar::Util 'reftype';
use namespace::clean -except => [qw( meta )];
use 5.008;
-our $VERSION = 0.09;
+our $VERSION = '0.22';
my $UndefMsg = q{Action for type '%s' not yet defined in library '%s'};
=head1 SYNOPSIS
PositiveInt NegativeInt
ArrayRefOfPositiveInt ArrayRefOfAtLeastThreeNegativeInts
LotsOfInnerConstraints StrOrArrayRef
+ MyDateTime
)];
# import builtin types
- use MooseX::Types::Moose 'Int';
+ use MooseX::Types::Moose qw/Int HashRef/;
# type definition.
subtype PositiveInt,
subtype StrOrArrayRef,
as Str|ArrayRef;
+ # class types
+
+ class_type 'DateTime';
+
+ # or better
+
+ class_type MyDateTime, { class => 'DateTime' };
+
+ coerce MyDateTime,
+ from HashRef,
+ via { DateTime->new(%$_) };
+
1;
=head2 Usage
This module will also provide you with some helper functions to make it
easier to use Moose types in your code.
+String type names will produce a warning, unless it's for a C<class_type> or
+C<role_type> declared within the library, or a fully qualified name like
+C<'MyTypeLibrary::Foo'>.
+
=head1 TYPE HANDLER FUNCTIONS
=head2 $type
package MyWrapper;
use strict;
- use Class::C3;
+ use MRO::Compat;
use base 'MooseX::Types::Wrapper';
sub coercion_export_generator {
A message that will be thrown when type functionality is used but the
type does not yet exist.
+=back
+
=head1 RECURSIVE SUBTYPES
As of version 0.08, L<Moose::Types> has experimental support for Recursive
}
# run type constraints import
- return Moose::Util::TypeConstraints->import({ into => $callee });
+ Moose::Util::TypeConstraints->import({ into => $callee });
+
+ # override some with versions that check for syntax errors
+ MooseX::Types::CheckedUtilExports->import({ into => $callee });
+
+ 1;
}
=head2 type_export_generator
## Return an anonymous subroutine that will generate the proxied type
## constraint for you.
-
- return sub {
- my $type_constraint;
+
+ return subname "__TYPE__::$name" => sub {
+ my $type_constraint = $class->create_base_type_constraint($name);
+
if(defined(my $params = shift @_)) {
## We currently only allow a TC to accept a single, ArrayRef
## parameter, as in HashRef[Int], where [Int] is what's inside the
## ArrayRef passed.
- if(ref $params eq 'ARRAY') {
+ if(reftype $params eq 'ARRAY') {
$type_constraint = $class->create_arged_type_constraint($name, @$params);
+ } elsif(!defined $type_constraint) {
+ croak "Syntax error in type definition (did you forget a comma"
+ . " after $type?)";
} else {
- croak 'Arguments must be an ArrayRef, not '. ref $params;
+ croak "Argument must be an ArrayRef to create a parameterized "
+ . "type, Eg.: ${type}[Int]. Got: ".ref($params)."."
}
- } else {
- $type_constraint = $class->create_base_type_constraint($name);
}
$type_constraint = defined($type_constraint) ? $type_constraint
sub create_arged_type_constraint {
my ($class, $name, @args) = @_;
my $type_constraint = Moose::Util::TypeConstraints::find_or_create_type_constraint("$name");
- return $type_constraint->parameterize(@args);
+ my $parameterized = $type_constraint->parameterize(@args);
+ # It's obnoxious to have to parameterize before looking for the TC, but the
+ # alternative is to hard-code the assumption that the name is
+ # "$name[$args[0]]", which would be worse.
+ # This breaks MXMS, unfortunately, which relies on things like Tuple[...]
+ # creating new type objects each time.
+ # if (my $existing =
+ # Moose::Util::TypeConstraints::find_type_constraint($parameterized->name)) {
+ # return $existing;
+ # }
+ # Moose::Util::TypeConstraints::register_type_constraint($parameterized);
+ return $parameterized;
}
=head2 create_base_type_constraint ($name)
L<MooseX::Types::Moose>,
L<Sub::Exporter>
-=head1 AUTHOR AND COPYRIGHT
+=head1 ACKNOWLEDGEMENTS
+
+Many thanks to the C<#moose> cabal on C<irc.perl.org>.
+
+=head1 AUTHOR
+
+Robert "phaylon" Sedlacek <rs@474.at>
+
+=head1 CONTRIBUTORS
+
+jnapiorkowski: John Napiorkowski <jjnapiork@cpan.org>
+
+caelum: Rafael Kitover <rkitover@cpan.org>
+
+rafl: Florian Ragwitz <rafl@debian.org>
+
+hdp: Hans Dieter Pearcey <hdp@cpan.org>
-Robert 'phaylon' Sedlacek C<E<lt>rs@474.atE<gt>>, with many thanks to
-the C<#moose> cabal on C<irc.perl.org>.
+autarch: Dave Rolsky <autarch@urth.org>
-Additional features by John Napiorkowski (jnapiorkowski) <jjnapiork@cpan.org>.
+=head1 COPYRIGHT & LICENSE
-=head1 LICENSE
+Copyright (c) 2007-2009 Robert Sedlacek <rs@474.at>
This program is free software; you can redistribute it and/or modify
it under the same terms as perl itself.
projects / gitmo/MooseX-Types.git / blobdiff