+package Moose::Cookbook;
-=pod
+# ABSTRACT: How to cook a Moose
+
+__END__
-=head1 NAME
-Moose::Cookbook - How to cook a Moose
+=pod
=head1 DESCRIPTION
-The Moose cookbook is a series of recipes taken from the Moose
-test suite. Each recipe presents some code, which demonstrates
-some of the features of Moose, and then proceeds to explain the
-details of the code.
+The Moose cookbook is a series of recipes showing various Moose
+features. Most recipes present some code demonstrating some feature,
+and then explain the details of the code.
-We also provide a L<Moose::Cookbook::FAQ> and a L<Moose::Cookbook::WTF>
-for common questions and problems people have with Moose.
+You should probably read the L<Moose::Manual> first. The manual
+explains Moose concepts without being too code-heavy.
=head1 RECIPES
=head2 Basic Moose
-These recipes will give you a good idea of what Moose is capable,
-starting with simple attribute declaration, and moving on to more
-powerful features like laziness, types, type coercion, method
-modifiers, and more.
+These recipes will give you a good overview of Moose's capabilities, starting
+with simple attribute declaration, and moving on to more powerful features like
+laziness, types, type coercion, method modifiers, and more.
=over 4
-=item L<Moose::Cookbook::Basics::Recipe1> - The (always classic) B<Point> example
+=item L<Moose::Cookbook::Basics::Point_AttributesAndSubclassing>
-A simple Moose-based class. Demonstrated Moose attributes and subclassing.
+A simple Moose-based class. Demonstrates basic Moose attributes and subclassing.
-=item L<Moose::Cookbook::Basics::Recipe2> - A simple B<BankAccount> example
+=item L<Moose::Cookbook::Basics::BankAccount_MethodModifiersAndSubclassing>
-A slightly more complex Moose class. Demonstrates using a method
-modifier in a subclass.
+A slightly more complex Moose class. Demonstrates using a method modifier in a
+subclass.
-=item L<Moose::Cookbook::Basics::Recipe3> - A lazy B<BinaryTree> example
+=item L<Moose::Cookbook::Basics::BinaryTree_AttributeFeatures>
Demonstrates several attribute features, including types, weak
-references, predicates ("does this object have a foo?"), defaults, and
-lazy attribute construction.
-
-=item L<Moose::Cookbook::Basics::Recipe4> - Subtypes, and modeling a simple B<Company> class hierarchy
+references, predicates ("does this object have a foo?"), defaults,
+laziness, and triggers.
-Introduces the creation and use of custom types, a C<BUILD> method,
-and the use of C<override> in a subclass.
+=item L<Moose::Cookbook::Basics::Company_Subtypes>
-=item L<Moose::Cookbook::Basics::Recipe5> - More subtypes, coercion in a B<Request> class
+Introduces the creation and use of custom types, a C<BUILD> method, and the
+use of C<override> in a subclass. This recipe also shows how to model a set of
+classes that could be used to model companies, people, employees, etc.
-More type examples, including the use of type coercions.
+=item L<Moose::Cookbook::Basics::HTTP_SubtypesAndCoercion>
-=item L<Moose::Cookbook::Basics::Recipe6> - The augment/inner example
+This recipe covers more subtype creation, including the use of type coercions.
-Demonstrates the use of C<augment> method modifiers, a way of turning
-the usual method overriding style "inside-out".
-
-=item L<Moose::Cookbook::Basics::Recipe7> - Making Moose fast with immutable
+=item L<Moose::Cookbook::Basics::Immutable>
Making a class immutable greatly increases the speed of accessors and
object construction.
-=item L<Moose::Cookbook::Basics::Recipe8> - Managing complex relations with trigger (TODO)
-
-I<abstract goes here>
-
-Work off of this http://code2.0beta.co.uk/moose/svn/Moose/trunk/t/200_examples/007_Child_Parent_attr_inherit.t
-
-=item L<Moose::Cookbook::Basics::Recipe9> - Builder methods and lazy_build
+=item L<Moose::Cookbook::Basics::BinaryTree_BuilderAndLazyBuild> - Builder methods and lazy_build
The builder feature provides an inheritable and role-composable way to
provide a default attribute value.
-=item L<Moose::Cookbook::Basics::Recipe10> - Operator overloading, subtypes, and coercion
+=item L<Moose::Cookbook::Basics::Genome_OverloadingSubtypesAndCoercion>
Demonstrates using operator overloading, coercion, and subtypes to
model how eye color is determined during reproduction.
-=item L<Moose::Cookbook::Basics::Recipe11> - BUILD and BUILDARGS (TODO)
+=item L<Moose::Cookbook::Basics::Person_BUILDARGSAndBUILD>
+
+This recipe demonstrates the use of C<BUILDARGS> and C<BUILD> to hook
+into object construction.
+
+=item L<Moose::Cookbook::Basics::DateTime_ExtendingNonMooseParent>
-We need a good recipe demonstrating how these work.
+In this recipe, we make a Moose-based subclass of L<DateTime>, a
+module which does not use Moose itself.
+
+=item L<Moose::Cookbook::Basics::Document_AugmentAndInner>
+
+Demonstrates the use of C<augment> method modifiers, a way of turning
+the usual method overriding style "inside-out".
=back
=over 4
-=item L<Moose::Cookbook::Roles::Recipe1> - The Moose::Role example
+=item L<Moose::Cookbook::Roles::Comparable_CodeReuse>
Demonstrates roles, which are also sometimes known as traits or
mix-ins. Roles provide a method of code re-use which is orthogonal to
subclassing.
-=item L<Moose::Cookbook::Roles::Recipe2> - Advanced Role Composition - method exclusion and aliasing
+=item L<Moose::Cookbook::Roles::Restartable_AdvancedComposition>
Sometimes you just want to include part of a role in your
-class. Sometimes you want the whole role but one if its methods
+class. Sometimes you want the whole role but one of its methods
conflicts with one in your class. With method exclusion and aliasing,
you can work around these problems.
-=item L<Moose::Cookbook::Roles::Recipe3> - Runtime Role Composition (TODO)
+=item L<Moose::Cookbook::Roles::ApplicationToInstance>
-I<abstract goes here>
+In this recipe, we apply a role to an existing object instance.
=back
=head2 Meta Moose
These recipes show you how to write your own meta classes, which lets
-you extend the object system provide by Moose.
+you extend the object system provided by Moose.
=over 4
-=item L<Moose::Cookbook::Meta::Recipe1> - Welcome to the meta-world (Why Go Meta?)
+=item L<Moose::Cookbook::Meta::WhyMeta>
If you're wondering what all this "meta" stuff is, and why you should
care about it, read this "recipe".
-=item L<Moose::Cookbook::Meta::Recipe2> - A meta-attribute, attributes with labels
-
-One way to extend Moose is to provide your own attribute
-metaclasses. Attribute metaclasses let you extend attribute
-declarations (with C<has>) and behavior to provide additional
-attribute functionality.
-
-=item L<Moose::Cookbook::Meta::Recipe3> - Labels implemented via attribute traits
+=item L<Moose::Cookbook::Meta::Labeled_AttributeTrait>
Extending Moose's attribute metaclass is a great way to add
functionality. However, attributes can only have one metaclass.
Applying roles to the attribute metaclass lets you provide
composable attribute functionality.
-=item L<Moose::Cookbook::Meta::Recipe4> - Adding a "table" attribute to the metaclass
+=item L<Moose::Cookbook::Meta::Table_MetaclassTrait>
-If you want to store more information about your classes, you'll have
-to extend C<Moose::Meta::Class>. Doing so is simple, but you'll
-probably also want to provide some sugar, so see
-L<Moose::Cookbook::Extending::Recipe2> as well.
+This recipe takes the class metaclass we saw in the previous recipe
+and reimplements it as a metaclass trait.
-=item L<Moose::Cookbook::Meta::Recipe5> - The "table" attribute implemented as a metaclass trait
+=item L<Moose::Cookbook::Meta::PrivateOrPublic_MethodMetaclass>
-This example takes the class metaclass we saw in the previous recipe
-and reimplements it as a metaclass trait.
+This recipe shows a custom method metaclass that implements making a
+method private.
-=item L<Moose::Cookbook::Meta::Recipe6> - Hooking into the immutabilization system (TODO)
+=item L<Moose::Cookbook::Meta::GlobRef_InstanceMetaclass>
+
+This recipe shows an example of how you create your own meta-instance
+class. The meta-instance determines the internal structure of object
+instances and provide access to attribute slots.
+
+In this particular instance, we use a blessed glob reference as the instance
+instead of a blessed hash reference.
+
+=item Hooking into immutabilization (TODO)
Moose has a feature known as "immutabilization". By calling C<<
__PACKAGE__->meta()->make_immutable() >> after defining your class
This recipe shows you how to write extensions which immutabilize
properly.
-=item L<Moose::Cookbook::Meta::Recipe7> - I<meta-instance> (TODO)
-
-I<abstract goes here>
-
=back
=head2 Extending Moose
=item L<Moose::Cookbook::Extending::Recipe1> - Moose extension overview
-There are quite a number of ways to extend Moose. This recipe explains
-provides an overview of each method, and provides recommendations for
-when each is appropriate.
+There are quite a few ways to extend Moose. This recipe provides an
+overview of each method, and provides recommendations for when each is
+appropriate.
=item L<Moose::Cookbook::Extending::Recipe2> - Providing a base object class role
=back
-=head1 AUTHOR
-
-Stevan Little E<lt>stevan@iinteractive.comE<gt>
-
-=head1 COPYRIGHT AND LICENSE
-
-Copyright 2006-2009 by Infinity Interactive, Inc.
-
-L<http://www.iinteractive.com>
-
-This library is free software; you can redistribute it and/or modify
-it under the same terms as Perl itself.
-
=cut
projects / gitmo/Moose.git / blobdiff