use Scalar::Util 'blessed';
use Moose::Exporter;
-our $VERSION = '0.59';
+our $VERSION = '0.65';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
Moose::Exporter->setup_import_methods(
as_is => [
qw(
- type subtype class_type role_type as where message optimize_as
+ type subtype class_type role_type maybe_type
+ as where message optimize_as
coerce from via
enum
find_type_constraint
);
}
+sub maybe_type {
+ my ($type_parameter) = @_;
+
+ register_type_constraint(
+ $REGISTRY->get_type_constraint('Maybe')->parameterize($type_parameter)
+ );
+}
+
sub coerce {
my ($type_name, @coercion_map) = @_;
_install_type_coercions($type_name, \@coercion_map);
}
my %opts = (
- name => $name || '__ANON__',
+ name => $name,
package_defined_in => $pkg_defined_in,
( $check ? ( constraint => $check ) : () ),
# define some basic built-in types
## --------------------------------------------------------
+# By making these classes immutable before creating all the types we
+# below, we avoid repeatedly calling the slow MOP-based accessors.
+$_->make_immutable(
+ inline_constructor => 1,
+ constructor_name => "_new",
+
+ # these are Class::MOP accessors, so they need inlining
+ inline_accessors => 1
+ ) for grep { $_->is_mutable }
+ map { $_->meta }
+ qw(
+ Moose::Meta::TypeConstraint
+ Moose::Meta::TypeConstraint::Union
+ Moose::Meta::TypeConstraint::Parameterized
+ Moose::Meta::TypeConstraint::Parameterizable
+ Moose::Meta::TypeConstraint::Class
+ Moose::Meta::TypeConstraint::Role
+ Moose::Meta::TypeConstraint::Enum
+ Moose::Meta::TypeConstraint::Registry
+);
+
type 'Any' => where { 1 }; # meta-type including all
type 'Item' => where { 1 }; # base-type
Creates a type constraint with the name C<$role> and the metaclass
L<Moose::Meta::TypeConstraint::Role>.
+=item B<maybe_type ($type)>
+
+Creates a type constraint for either C<undef> or something of the
+given type.
+
=item B<enum ($name, @values)>
This will create a basic subtype for a given set of strings.
=item B<find_or_create_does_type_constraint ($type_name)>
-Attempts to parse the type name using L<find_or_parse_type_constraint> and if
+Attempts to parse the type name using C<find_or_parse_type_constraint> and if
no appropriate constraint is found will create a new anonymous one.
The C<isa> variant will use C<create_class_type_constraint> and the C<does>