Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
MooX::Types::MooseLikeUser Contributed Perl DocumentaMooX::Types::MooseLike(3)

NAME
       MooX::Types::MooseLike -	some Moosish types and a type builder

SYNOPSIS
	 package MyApp::Types;
	 use MooX::Types::MooseLike;
	 use base qw(Exporter);
	 our @EXPORT_OK	= ();

	 # Define some types
	 my $defs = [{
	   name	=> 'MyType',
	   test	=> sub { predicate($_[0]) },
	   message => sub { "$_[0] is not the type we want!" }
	 },
	 {
	   name	=> 'VarChar',
	   test	=> sub {
	     my	($value, $param) = @_;
	     length($value) <= $param;
	   },
	   message => sub { "$_[0] is too large! It should be less than	or equal to $_[1]." }
	 }];

	 # Make	the types available - this adds	them to	@EXPORT_OK automatically.
	 MooX::Types::MooseLike::register_types($defs, __PACKAGE__);

	 ...

	 # Somewhere in	code that uses the type
	 package MyApp::Foo;
	 use Moo;
	 use MyApp::Types qw(MyType VarChar);

	 has attribute => (
	   is  => 'ro',
	   isa => MyType,
	 );

	 has string => (
	   is  => 'ro',
	   isa => VarChar[25]
	 );

DESCRIPTION
       This module provides a possibility to build your	own set	of Moose-like
       types. These custom types can then be used to describe fields in	Moo-
       based classes.

       See MooX::Types::MooseLike::Base	for a list of available	base types.
       Its source also provides	an example of how to build base	types, along
       with both parameterizable and non-parameterizable.

FUNCTIONS
   register_types
       register_types( types, package, moose_namespace )

       Install the given types within the package. This	makes the types
       automatically exportable	by adding them to @EXPORT_OK of	the package.
       Types are expected to be	an array ref where every type is of the
       following format:

	 {
	   name		   => 'MyType',
	   test		   => sub { check_the_value_somehow($_[0]) },
	   message	   => sub { "$_[0] is not the type we want!" },
	   subtype_of	   => 'SomeParentType',		  # Optional
	   from		   => 'Some::Parent::CoolTypes',  # Optional
	   parameterizable => sub { ...	},		  # Optional
	   inflate	   => sub { ...	},		  # Optional
	 }

       A type can be declared with a reference (subtype_of) to some previously
       declared	type. In this case the new type	will inherit the behaviour of
       the referenced type.

       The referenced type can come either from	the same package or from a
       third party package:

	 MooX::Types::MooseLike::register_types([{
	   name	      => 'GreaterThan10',
	   subtype_of => 'Int',
	   from	      => 'MooX::Types::MooseLike::Base',
	   test	      => sub { $_[0] > 10 },
	   message    => sub { 'not greater than 10' },
	 }], __PACKAGE__);

	 MooX::Types::MooseLike::register_types([{
	   name	      => 'Between10And20',
	   subtype_of => 'GreaterThan10',
	   from	      => __PACKAGE__,
	   test	      => sub { $_[0] < 20 },
	   message    => sub { 'not an integer between 10 and 20' },
	 }], __PACKAGE__);

	 MooX::Types::MooseLike::register_types([{
	   name	      => 'Between10And30',
	   subtype_of => GreaterThan10(),
	   test	      => sub { $_[0] < 30 },
	   message    => sub { 'not an integer between 10 and 30' },
	 }], __PACKAGE__);

   exception_message
       exception_message( value, part_of_the_exception_string )

       Helper function to be used in a type definition:

	 {
	   ...
	   message => sub { return exception_message($_[0], 'a HashRef'	},
	   ...
	 }

       In the event of <value> mismatching the type constraints	it produces
       the message:

	 "<value> is not a HashRef!"

   inflate_type
       inflate_type( coderef )

       Inflates	the type to a Moose type. Requires Moose.

SEE ALSO
       MooX::Types::MooseLike::Numeric - an example of building	subtypes.

       MooX::Types::SetObject -	an example of building parameterized types.

       MooX::Types::MooseLike::Email, MooX::Types::MooseLike::DateTime

       Type::Tiny - another implementation of type constraints.	Compatible
       with Moo, Moose and Mouse.

AUTHOR
       mateu - Mateu X.	Hunter (cpan:MATEU) <hunter@missoula.org>

CONTRIBUTORS
       mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>

       Mithaldu	- Christian Walde (cpan:MITHALDU)
       <walde.christian@googlemail.com>

       Matt Phillips (cpan:MATTP) <mattp@cpan.org>

       Arthur Axel fREW	Schmidt	(cpan:FREW) <frioux@gmail.com>

       Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>

       Graham Knop (cpan:HAARG)	<haarg@cpan.org>

       Dmitry Matrosov (cpan:AMIDOS) <amidos@amidos.ru>

COPYRIGHT
       Copyright (c) 2011-2015 the MooX::Types::MooseLike "AUTHOR" and
	"CONTRIBUTORS" as listed above.

LICENSE
       This library is free software and may be	distributed under the same
       terms as	perl itself.

perl v5.32.1			  2015-06-26	     MooX::Types::MooseLike(3)

NAME | SYNOPSIS | DESCRIPTION | FUNCTIONS | SEE ALSO | AUTHOR | CONTRIBUTORS | COPYRIGHT | LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=MooX::Types::MooseLike&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help