lib/Moose/Cookbook.pod

   1
   2 =pod
   3
   4 =head1 NAME
   5
   6 Moose::Cookbook - How to cook a Moose
   7
   8 =head1 DESCRIPTION
   9
  10 The Moose cookbook is a series of recipes taken from the Moose
  11 test suite. Each recipe presents some code, which demonstrates
  12 some of the features of Moose, and then proceeds to explain the
  13 details of the code.
  14
  15 We also provide a L<Moose::Cookbook::FAQ> and a L<Moose::Cookbook::WTF>
  16 for common questions and problems people have with Moose.
  17
  18 =head1 RECIPES
  19
  20 =head2 Basic Moose
  21
  22 These recipes will give you a good idea of what Moose is capable,
  23 starting with simple attribute declaration, and moving on to more
  24 powerful features like laziness, types, type coercion, method
  25 modifiers, and more.
  26
  27 =over 4
  28
  29 =item L<Moose::Cookbook::Basics::Recipe1> - The (always classic) B<Point> example
  30
  31 A simple Moose-based class. Demonstrated Moose attributes and subclassing.
  32
  33 =item L<Moose::Cookbook::Basics::Recipe2> - A simple B<BankAccount> example
  34
  35 A slightly more complex Moose class. Demonstrates using a method
  36 modifier in a subclass.
  37
  38 =item L<Moose::Cookbook::Basics::Recipe3> - A lazy B<BinaryTree> example
  39
  40 Demonstrates several attribute features, including types, weak
  41 references, predicates ("does this object have a foo?"), defaults, and
  42 lazy attribute uction.
  43
  44 =item L<Moose::Cookbook::Basics::Recipe4> - Subtypes, and modeling a simple B<Company> class hierarchy
  45
  46 Introduces the creation and use of custom types, a C<BUILD> method,
  47 and the use of C<override> in a subclass.
  48
  49 =item L<Moose::Cookbook::Basics::Recipe5> - More subtypes, coercion in a B<Request> class
  50
  51 More type examples, including the use of type coercions.
  52
  53 =item L<Moose::Cookbook::Basics::Recipe6> - The augment/inner example
  54
  55 Demonstrates the use of C<augment> method modifiers, a way of turning
  56 the usual method overriding style "inside-out".
  57
  58 =item L<Moose::Cookbook::Basics::Recipe7> - Making Moose fast with immutable
  59
  60 Making a class immutable greatly increases the speed of accessors and
  61 object construction.
  62
  63 =item L<Moose::Cookbook::Basics::Recipe8> - Managing complex relations with trigger (TODO)
  64
  65 I<abstract goes here>
  66
  67 Work off of this http://code2.0beta.co.uk/moose/svn/Moose/trunk/t/200_examples/007_Child_Parent_attr_inherit.t
  68
  69 =item L<Moose::Cookbook::Basics::Recipe9> - Builder methods and lazy_build
  70
  71 The builder feature provides an inheritable and role-composable way to
  72 provide a default attribute value.
  73
  74 =item L<Moose::Cookbook::Basics::Recipe10> - Operator overloading, subtypes, and coercion
  75
  76 Demonstrates using operator overloading, coercion, and subtypes to
  77 model how eye color is determined during reproduction.
  78
  79 =back
  80
  81 =head2 Moose Roles
  82
  83 These recipes will show you how to use Moose roles.
  84
  85 =over 4
  86
  87 =item L<Moose::Cookbook::Role::Recipe1> - The Moose::Role example
  88
  89 Demonstrates roles, which are also sometimes known as traits or
  90 mix-ins. Roles provide a method of code re-use which is orthogonal to
  91 subclassing.
  92
  93 =item L<Moose::Cookbook::Role::Recipe2> - Advanced Role Composition - method exclusion and aliasing
  94
  95 Sometimes you just want to include part of a role in your
  96 class. Sometimes you want the whole role but one if its methods
  97 conflicts with one in your class. With method exclusion and aliasing,
  98 you can work around these problems.
  99
 100 =item L<Moose::Cookbook::Role::Recipe3> - Runtime Role Composition (TODO)
 101
 102 I<abstract goes here>
 103
 104 =back
 105
 106 =head2 Meta Moose
 107
 108 These recipes show you how to write your own meta classes, which lets
 109 you extend the object system provide by Moose.
 110
 111 =over 4
 112
 113 =item L<Moose::Cookbook::Meta::Recipe1> - Welcome to the meta-world (Why Go Meta?)
 114
 115 If you're wondering what all this "meta" stuff is, and why you should
 116 care about it, read this "recipe".
 117
 118 =item L<Moose::Cookbook::Meta::Recipe2> - A meta-attribute, attributes with labels
 119
 120 One way to extend Moose is to provide your own attribute
 121 metaclasses. Attribute metaclasses let you extend attribute
 122 declarations (with C<has>) and behavior to provide additional
 123 attribute functionality.
 124
 125 =item L<Moose::Cookbook::Meta::Recipe3> - Labels implemented via attribute traits
 126
 127 Extending Moose's attribute metaclass is a great way to add
 128 functionality. However, attributes can only have one metaclass.
 129 Applying roles to the attribute metaclass lets you provide
 130 composable attribute functionality.
 131
 132 =item L<Moose::Cookbook::Meta::Recipe4> - Adding a "table" attribute to the metaclass
 133
 134 If you want to store more information about your classes, you'll have
 135 to extend C<Moose::Meta::Class>. Doing so is simple, but you'll
 136 probably also want to provide some sugar, so see
 137 L<Moose::Cookbook::Extending::Recipe2> as well.
 138
 139 =item L<Moose::Cookbook::Meta::Recipe5> - The "table" attribute implemented as a metaclass trait
 140
 141 This example takes the class metaclass we saw in the previous recipe
 142 and reimplements it as a metaclass trait.
 143
 144 =item L<Moose::Cookbook::Meta::Recipe6> - Hooking into the immutabilization system (TODO)
 145
 146 Moose has a feature known as "immutabilization". By calling C<<
 147 __PACKAGE__->meta()->make_immutable() >> after defining your class
 148 (attributes, roles, etc), you tell Moose to optimize things like
 149 object creation, attribute access, and so on.
 150
 151 If you are creating your own metaclasses, you may need to hook into
 152 the immutabilization system. This cuts across a number of spots,
 153 including the metaclass class, meta method classes, and possibly the
 154 meta-instance class as well.
 155
 156 This recipe shows you how to write extensions which immutabilize
 157 properly.
 158
 159 =item L<Moose::Cookbook::Meta::Recipe7> - I<meta-instance> (TODO)
 160
 161 I<abstract goes here>
 162
 163 =back
 164
 165 =head2 Extending Moose
 166
 167 These recipes cover some more ways to extend Moose, and will be useful
 168 if you plan to write your own C<MooseX> module.
 169
 170 =over 4
 171
 172 =item L<Moose::Cookbook::Extending::Recipe1> - Providing an alternate base object class
 173
 174 You may find that you want to provide an alternate base object class
 175 along with a meta extension, or maybe you just want to add some
 176 functionality to all your classes without typing C<extends
 177 'MyApp::Base'> over and over.
 178
 179 =item L<Moose::Cookbook::Extending::Recipe2> - Acting like Moose.pm and providing sugar Moose-style
 180
 181 This recipe shows how to provide a replacement for C<Moose.pm>. You
 182 may want to do this as part of the API for a C<MooseX> module,
 183 especially if you want to default to a new metaclass class or base
 184 object class.
 185
 186 =back
 187
 188 =head1 SNACKS
 189
 190 =over 4
 191
 192 =item L<Moose::Cookbook::Snack::Keywords>
 193
 194 =item L<Moose::Cookbook::Snack::Types>
 195
 196 =back
 197
 198 =head1 SEE ALSO
 199
 200 =over 4
 201
 202 =item L<http://www.gsph.com/index.php?Lang=En&ID=291>
 203
 204 =back
 205
 206 =head1 AUTHOR
 207
 208 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 209
 210 =head1 COPYRIGHT AND LICENSE
 211
 212 Copyright 2006-2008 by Infinity Interactive, Inc.
 213
 214 L<http://www.iinteractive.com>
 215
 216 This library is free software; you can redistribute it and/or modify
 217 it under the same terms as Perl itself.
 218
 219 =cut