GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MOOX::TYPES::MOOSELIKE (3)

.ds Aq ’

NAME

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

CONTENTS

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

<B>register_types( types, package, moose_namespace )B>

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

<B>exception_message( value, part_of_the_exception_string )B>

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

<B>inflate_type( coderef )B>

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.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MOOX::TYPES::MOOSELIKE (3) 2015-06-26

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.