++ed by:
ROMANF

1 PAUSE user
1 non-PAUSE user.

Toby Inkster

NAME

MooseX::Types::MoreUtils - utility methods to apply to Moose type constraints

SYNOPSIS

   {
      package Spruce;
      
      use Moose;
      use MooseX::Types::Moose qw(ArrayRef Str);
      use MooseX::Types::MoreUtils;
      use Local::TextUtils qw( csv_to_arrayref );
      
      has goose => (
         is      => 'ro',
         isa     => ArrayRef->$_plus_coercions( Str, \&csv_to_arrayref ),
         coerce  => 1,
      );
   }

DESCRIPTION

This module provides a bunch of methods for working with Moose type constraints, which it exposes as lexical coderef variables. (Like Object::Util.)

See "Rationale" in Object::Util.

Methods

The invocants for these methods are type constraints. These may be Moose::Meta::TypeConstraint, MooseX::Types::TypeDecorator, or Type::Tiny objects. As a convenience, strings are also accepted, which will be looked up via Moose's find_or_create_type_constraint utility function. Various other conveniences are provided; see "Shortcuts for type constraints".

Constraint manipulation

$_where

Creates an anonymous subtype with an additional constraint. For example to create a type constraint that accepts odd-numbered integers, you could use:

   isa => Int->$_where(sub { $_ % 2 })

Alternatively the coderef can be replaced with a string of Perl code:

   isa => Int->$_where('$_ % 2')
$_of

Can be used to parameterize type constraints. For example, for an arrayref of odd integers:

   isa => ArrayRef->$_of(  Int->$_where('$_ % 2')  )

Or if you'd prefer, an arrayref of integers, where the arrayref contains an odd number of items:

   isa => ArrayRef->$_of(Int)->$_where('@$_ % 2')
$_type

The identity function. Int->$_type just returns Int.

This is occasionally useful if you're taking advantage of the fact that the invocant doesn't have to be a real type constraint but can instead use a shortcut. In these cases it's not quite the identity, because it returns a real type constraint object.

Coercion manipulation

$_plus_coercions

Given an existing type constraint, creates a new child type with some extra coercions.

   isa => ArrayRef->$_plus_coercions(
      Str,         \&csv_to_arrayref,
      "HashRef",   sub { [ values(%$_) ] },
   ),
   coerce => 1,
$_minus_coercions

Given an existing type constraint, creates a new child type with fewer coercions.

   use MooseX::Types::Moose qw( HashRef );
   use MooseX::Types::URI qw( Uri );
   
   # Don't want to coerce from HashRef,
   # but keep the coercion from Str.
   #
   isa => Uri->$_minus_coercions(HashRef)
$_no_coercions

Given an existing type constraint, creates a new child type with no coercions at all.

   isa => Uri->$_no_coercions

As above, it's just equivalent to coerce => 0 so might seem a bit useless. But it is handy when chained with $_plus_coercions to provide a stable base to build your coercions on:

   # This doesn't just create a type like Uri but
   # with extra coercions; it explicitly ignores any
   # coercions that were already attached to Uri.
   #
   isa => Uri->$_no_coercions->$_plus_coercions(
      Str, sub { ... }
   );

Shortcuts for type constraints

Where type constraints are expected by this module, you can take some shortcuts. Strings are passed to find_or_create_type_constraint for example, meaning that the following two exampes are identical:

With MooseX::Types...

   use MooseX::Types::Moose qw( ArrayRef Str );
   ArrayRef->$_plus_coercions( Str, \&csv_to_arrayref );

Without MooseX::Types...

   "ArrayRef"->$_plus_coercions( "Str", \&csv_to_arrayref );

If, instead of a type constraint you give a coderef, this will be converted into a subtype of Any.

You may also give a hashref with a single key-value pair, such as:

   { class => "Some::Class::Name" }
   { role => "Some::Role::Name" }
   { duck => \@method_names }
   { union => \@type_constraints }
   { enum => \@strings }

These do what I think you'd expect them to do.

CAVEATS

This module does not remove the need for coerce => 1!

BUGS

Please report any bugs to http://rt.cpan.org/Dist/Display.html?Queue=MooseX-Types-MoreUtils.

SEE ALSO

If you use Types::Standard, this module is fairly redundant, as these features and shortcuts are mostly built-in!

AUTHOR

Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE

This software is copyright (c) 2014 by Toby Inkster.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

DISCLAIMER OF WARRANTIES

THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.