}
sub create_type_constraint_union {
- my @type_constraint_names;
-
- if ( scalar @_ == 1 && _detect_type_constraint_union( $_[0] ) ) {
- @type_constraint_names = _parse_type_constraint_union( $_[0] );
- }
- else {
- @type_constraint_names = @_;
- }
-
- ( scalar @type_constraint_names >= 2 )
- || __PACKAGE__->_throw_error(
- "You must pass in at least 2 type names to make a union");
-
- my @type_constraints = map {
- find_or_parse_type_constraint($_)
- || __PACKAGE__->_throw_error(
- "Could not locate type constraint ($_) for the union");
- } @type_constraint_names;
-
- return Moose::Meta::TypeConstraint::Union->new(
- type_constraints => \@type_constraints );
+ _create_type_constraint_union(\@_);
}
sub create_named_type_constraint_union {
my $name = shift;
+ _create_type_constraint_union($name, \@_);
+}
+
+sub _create_type_constraint_union {
+ my $name;
+ $name = shift if @_ > 1;
+ my @tcs = @{ shift() };
+
my @type_constraint_names;
- if ( scalar @_ == 1 && _detect_type_constraint_union( $_[0] ) ) {
- @type_constraint_names = _parse_type_constraint_union( $_[0] );
+ if ( scalar @tcs == 1 && _detect_type_constraint_union( $tcs[0] ) ) {
+ @type_constraint_names = _parse_type_constraint_union( $tcs[0] );
}
else {
- @type_constraint_names = @_;
+ @type_constraint_names = @tcs;
}
( scalar @type_constraint_names >= 2 )
from 'Str',
via { 0+$_ };
+ class_type 'DateTimeish', { class => 'DateTime' };
+
+ role_type 'Barks', { role => 'Some::Library::Role::Barks' };
+
enum 'RGBColors', [qw(red green blue)];
union 'StringOrArray', [qw( String Array )];
Creates a new subtype of C<Object> with the name C<$class> and the
metaclass L<Moose::Meta::TypeConstraint::Class>.
+ # Create a type called 'Box' which tests for objects which ->isa('Box')
+ class_type 'Box';
+
+Additionally, you can create a class_type which is a shorthand for another class.
+
+ # Create a type called 'Box' which tests for objects which ->isa('ObjectLibrary::Box');
+ class_type 'Box', { class => 'ObjectLibrary::Box' };
+
+But it's only really necessary to do this if you're working with L<MooseX::Types>.
+
=item B<role_type ($role, ?$options)>
Creates a C<Role> type constraint with the name C<$role> and the
metaclass L<Moose::Meta::TypeConstraint::Role>.
+ # Create a type called 'Walks' which tests for objects which ->does('Walks')
+ role_type 'Walks';
+
+Additionally, you can create a role_type which is a shorthand for another role.
+
+ # Create a type called 'Walks' which tests for objects which ->does('MooseX::Role::Walks');
+ role_type 'Walks', { role => 'MooseX::Role::Walks' };
+
+But it's only really necessary to do this if you're working with L<MooseX::Types>.
+
=item B<maybe_type ($type)>
Creates a type constraint for either C<undef> or something of the
=item B<create_type_constraint_union($pipe_separated_types | @type_constraint_names)>
+=item B<create_named_type_constraint_union($name, $pipe_separated_types | @type_constraint_names)>
+
This can take a union type specification like C<'Int|ArrayRef[Int]'>,
or a list of names. It returns a new
L<Moose::Meta::TypeConstraint::Union> object.