Moose::Manual::MooseX(3pm)     User Contributed Perl Documentation     Moose::Manual::MooseX(3pm)



NAME
       Moose::Manual::MooseX - Recommended Moose extensions

VERSION
       version 2.1213

MooseX?
       It's easy to extend and change Moose, and this is part of what makes Moose so powerful.
       You can use the MOP API to do things your own way, add new features, and generally
       customize your Moose.

       Writing your own extensions does require a good understanding of the meta-model. You can
       start learning about this with the Moose::Manual::MOP docs. There are also several
       extension recipes in the Moose::Cookbook.

       Explaining how to write extensions is beyond the scope of this manual. Fortunately, lots
       of people have already written extensions and put them on CPAN for you.

       This document covers a few of the ones we like best.

MooseX::AttributeHelpers
       The functionality of this MooseX module has been moved into Moose core.  See
       Moose::Meta::Attribute::Native.

Moose::Autobox
       MooseX::AttributeHelpers, but turned inside out, Moose::Autobox provides methods on both
       arrays/hashes/etc. but also references to them, using Moose roles, allowing you do to
       things like:

         use Moose::Autobox;

         $somebody_elses_object->orders->push($order);

       Lexically scoped and not to everybody's taste, but very handy for sugaring up other
       people's APIs and your own code.

MooseX::StrictConstructor
       By default, Moose lets you pass any old junk into a class's constructor. If you load
       MooseX::StrictConstructor, your class will throw an error if it sees something it doesn't
       recognize;

         package User;

         use Moose;
         use MooseX::StrictConstructor;

         has 'name';
         has 'email';

         User->new( name => 'Bob', emali => 'bob AT example.com' );

       With MooseX::StrictConstructor, that typo ("emali") will cause a runtime error. With plain
       old Moose, the "emali" attribute would be silently ignored.

MooseX::Params::Validate
       We have high hopes for the future of MooseX::Method::Signatures and MooseX::Declare.
       However, these modules, while used regularly in production by some of the more insane
       members of the community, are still marked alpha just in case backwards incompatible
       changes need to be made.

       If you don't want to risk that, for now we recommend the decidedly more clunky (but also
       faster and simpler) MooseX::Params::Validate. This module lets you apply Moose types and
       coercions to any method arguments.

         package User;

         use Moose;
         use MooseX::Params::Validate;

         sub login {
             my $self = shift;
             my ($password)
                 = validated_list( \@_, password => { isa => 'Str', required => 1 } );

             ...
         }

MooseX::Getopt
       This is a role which adds a "new_with_options" method to your class. This is a constructor
       that takes the command line options and uses them to populate attributes.

       This makes writing a command-line application as a module trivially simple:

         package App::Foo;

         use Moose;
         with 'MooseX::Getopt';

         has 'input' => (
             is       => 'ro',
             isa      => 'Str',
             required => 1
         );

         has 'output' => (
             is       => 'ro',
             isa      => 'Str',
             required => 1
         );

         sub run { ... }

       Then in the script that gets run we have:

         use App::Foo;

         App::Foo->new_with_options->run;

       From the command line, someone can execute the script:

         foo@example> foo --input /path/to/input --output /path/to/output

MooseX::Singleton
       To be honest, using a singleton is just a way to have a magic global variable in languages
       that don't actually have global variables.

       In perl, you can just as easily use a global. However, if your colleagues are Java-
       infected, they might prefer a singleton. Also, if you have an existing class that isn't a
       singleton but should be, using MooseX::Singleton is the easiest way to convert it.

         package Config;

         use MooseX::Singleton; # instead of Moose

         has 'cache_dir' => ( ... );

       It's that simple.

EXTENSIONS TO CONSIDER
       There are literally dozens of other extensions on CPAN. This is a list of extensions that
       you might find useful, but we're not quite ready to endorse just yet.

   MooseX::Declare
       Extends Perl with Moose-based keywords using "Devel::Declare". Very cool, but still new
       and experimental.

         class User {

             has 'name'  => ( ... );
             has 'email' => ( ... );

             method login (Str $password) { ... }
         }

   MooseX::Types
       This extension helps you build a type library for your application. It also lets you
       predeclare type names and use them as barewords.

         use MooseX::Types -declare => ['PositiveInt'];
         use MooseX::Types::Moose 'Int';

         subtype PositiveInt,
             as Int,
             where { $_ > 0 },
             message { "Int is not larger than 0" };

       One nice feature is that those bareword names are actually namespaced in Moose's type
       registry, so multiple applications can use the same bareword names, even if the type
       definitions differ.

   MooseX::Types::Structured
       This extension builds on top of MooseX::Types to let you declare complex data structure
       types.

         use MooseX::Types -declare => [ qw( Name Color ) ];
         use MooseX::Types::Moose qw(Str Int);
         use MooseX::Types::Structured qw(Dict Tuple Optional);

         subtype Name
             => as Dict[ first => Str, middle => Optional[Str], last => Str ];

         subtype Color
             => as Tuple[ Int, Int, Int, Optional[Int] ];

       Of course, you could always use objects to represent these sorts of things too.

   MooseX::ClassAttribute
       This extension provides class attributes for Moose classes. The declared class attributes
       are introspectable just like regular Moose attributes.

         package User;

         use Moose;
         use MooseX::ClassAttribute;

         has 'name' => ( ... );

         class_has 'Cache' => ( ... );

       Note however that this class attribute does not inherit like a Class::Data::Inheritable or
       similar attribute - calling

         $subclass->Cache($cache);

       will set it for the superclass as well. Additionally, class data is usually The Wrong
       Thing To Do in a strongly OO program since it makes testing a lot harder - consider
       carefully whether you'd be better off with an object that's passed around instead.

   MooseX::Daemonize
       This is a role that provides a number of methods useful for creating a daemon, including
       methods for starting and stopping, managing a PID file, and signal handling.

   MooseX::Role::Parameterized
       If you find yourself wanting a role that customizes itself for each consumer, this is the
       tool for you. With this module, you can create a role that accepts parameters and
       generates attributes, methods, etc. on a customized basis for each consumer.

   MooseX::POE
       This is a small wrapper that ties together a Moose class with "POE::Session", and gives
       you an "event" sugar function to declare event handlers.

   MooseX::FollowPBP
       Automatically names all accessors Perl Best Practices-style, "get_size" and "set_size".

   MooseX::SemiAffordanceAccessor
       Automatically names all accessors with an explicit set and implicit get, "size" and
       "set_size".

   MooseX::NonMoose
       MooseX::NonMoose allows for easily subclassing non-Moose classes with Moose, taking care
       of the annoying details connected with doing this, such as setting up proper inheritance
       from Moose::Object and installing (and inlining, at make_immutable time) a constructor
       that makes sure things like BUILD methods are called.

AUTHORS
       ·   Stevan Little <stevan.little AT iinteractive.com>

       ·   Dave Rolsky <autarch AT urth.org>

       ·   Jesse Luehrs <doy AT tozt.net>

       ·   Shawn M Moore <code AT sartak.org>

       ·   XXXX XXX'XX (Yuval Kogman) <nothingmuch AT woobling.org>

       ·   Karen Etheridge <ether AT cpan.org>

       ·   Florian Ragwitz <rafl AT debian.org>

       ·   Hans Dieter Pearcey <hdp AT weftsoar.net>

       ·   Chris Prather <chris AT prather.org>

       ·   Matt S Trout <mst AT shadowcat.uk>

COPYRIGHT AND LICENSE
       This software is copyright (c) 2006 by Infinity Interactive, Inc..

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



perl v5.20.1                                2014-09-25                 Moose::Manual::MooseX(3pm)