Bump version
[gitmo/Moo.git] / lib / Moo.pm
1 package Moo;
2
3 use strictures 1;
4 use Moo::_Utils;
5 use B 'perlstring';
6 use Sub::Defer ();
7
8 our $VERSION = '1.000006'; # 1.0.6
9 $VERSION = eval $VERSION;
10
11 require Moo::sification;
12
13 our %MAKERS;
14
15 sub _install_tracked {
16   my ($target, $name, $code) = @_;
17   $MAKERS{$target}{exports}{$name} = $code;
18   _install_coderef "${target}::${name}" => "Moo::${name}" => $code;
19 }
20
21 sub import {
22   my $target = caller;
23   my $class = shift;
24   strictures->import;
25   return if $MAKERS{$target}; # already exported into this package
26   $MAKERS{$target} = {};
27   _install_tracked $target => extends => sub {
28     $class->_set_superclasses($target, @_);
29     $class->_maybe_reset_handlemoose($target);
30     return;
31   };
32   _install_tracked $target => with => sub {
33     require Moo::Role;
34     Moo::Role->apply_roles_to_package($target, @_);
35     $class->_maybe_reset_handlemoose($target);
36   };
37   _install_tracked $target => has => sub {
38     my ($name_proto, %spec) = @_;
39     my $name_isref = ref $name_proto eq 'ARRAY';
40     foreach my $name ($name_isref ? @$name_proto : $name_proto) {
41       # Note that when $name_proto is an arrayref, each attribute
42       # needs a separate \%specs hashref
43       my $spec_ref = $name_isref ? +{%spec} : \%spec;
44       $class->_constructor_maker_for($target)
45             ->register_attribute_specs($name, $spec_ref);
46       $class->_accessor_maker_for($target)
47             ->generate_method($target, $name, $spec_ref);
48       $class->_maybe_reset_handlemoose($target);
49     }
50     return;
51   };
52   foreach my $type (qw(before after around)) {
53     _install_tracked $target => $type => sub {
54       require Class::Method::Modifiers;
55       _install_modifier($target, $type, @_);
56       return;
57     };
58   }
59   {
60     no strict 'refs';
61     @{"${target}::ISA"} = do {
62       require Moo::Object; ('Moo::Object');
63     } unless @{"${target}::ISA"};
64   }
65   if ($INC{'Moo/HandleMoose.pm'}) {
66     Moo::HandleMoose::inject_fake_metaclass_for($target);
67   }
68 }
69
70 sub unimport {
71   my $target = caller;
72   _unimport_coderefs($target, $MAKERS{$target});
73 }
74
75 sub _set_superclasses {
76   my $class = shift;
77   my $target = shift;
78   foreach my $superclass (@_) {
79     _load_module($superclass);
80     if ($INC{"Role/Tiny.pm"} && $Role::Tiny::INFO{$superclass}) {
81       require Carp;
82       Carp::croak("Can't extend role '$superclass'");
83     }
84   }
85   # Can't do *{...} = \@_ or 5.10.0's mro.pm stops seeing @ISA
86   @{*{_getglob("${target}::ISA")}{ARRAY}} = @_;
87   if (my $old = delete $Moo::MAKERS{$target}{constructor}) {
88     delete _getstash($target)->{new};
89     Moo->_constructor_maker_for($target)
90        ->register_attribute_specs(%{$old->all_attribute_specs});
91   }
92   no warnings 'once'; # piss off. -- mst
93   $Moo::HandleMoose::MOUSE{$target} = [
94     grep defined, map Mouse::Util::find_meta($_), @_
95   ] if $INC{"Mouse.pm"};
96 }
97
98 sub _maybe_reset_handlemoose {
99   my ($class, $target) = @_;
100   if ($INC{"Moo/HandleMoose.pm"}) {
101     Moo::HandleMoose::maybe_reinject_fake_metaclass_for($target);
102   }
103 }
104
105 sub _accessor_maker_for {
106   my ($class, $target) = @_;
107   return unless $MAKERS{$target};
108   $MAKERS{$target}{accessor} ||= do {
109     my $maker_class = do {
110       if (my $m = do {
111             if (my $defer_target = 
112                   (Sub::Defer::defer_info($target->can('new'))||[])->[0]
113               ) {
114               my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
115               $MAKERS{$pkg} && $MAKERS{$pkg}{accessor};
116             } else {
117               undef;
118             }
119           }) {
120         ref($m);
121       } else {
122         require Method::Generate::Accessor;
123         'Method::Generate::Accessor'
124       }
125     };
126     $maker_class->new;
127   }
128 }
129
130 sub _constructor_maker_for {
131   my ($class, $target, $select_super) = @_;
132   return unless $MAKERS{$target};
133   $MAKERS{$target}{constructor} ||= do {
134     require Method::Generate::Constructor;
135     require Sub::Defer;
136     my ($moo_constructor, $con);
137
138     if ($select_super && $MAKERS{$select_super}) {
139       $moo_constructor = 1;
140       $con = $MAKERS{$select_super}{constructor};
141     } else {
142       my $t_new = $target->can('new');
143       if ($t_new) {
144         if ($t_new == Moo::Object->can('new')) {
145           $moo_constructor = 1;
146         } elsif (my $defer_target = (Sub::Defer::defer_info($t_new)||[])->[0]) {
147           my ($pkg) = ($defer_target =~ /^(.*)::[^:]+$/);
148           if ($MAKERS{$pkg}) {
149             $moo_constructor = 1;
150             $con = $MAKERS{$pkg}{constructor};
151           }
152         }
153       } else {
154         $moo_constructor = 1; # no other constructor, make a Moo one
155       }
156     };
157     ($con ? ref($con) : 'Method::Generate::Constructor')
158       ->new(
159         package => $target,
160         accessor_generator => $class->_accessor_maker_for($target),
161         construction_string => (
162           $moo_constructor
163             ? ($con ? $con->construction_string : undef)
164             : ('$class->'.$target.'::SUPER::new(@_)')
165         ),
166         subconstructor_handler => (
167           '      if ($Moo::MAKERS{$class}) {'."\n"
168           .'        '.$class.'->_constructor_maker_for($class,'.perlstring($target).');'."\n"
169           .'        return $class->new(@_)'.";\n"
170           .'      } elsif ($INC{"Moose.pm"} and my $meta = Class::MOP::get_metaclass_by_name($class)) {'."\n"
171           .'        return $meta->new_object($class->BUILDARGS(@_));'."\n"
172           .'      }'."\n"
173         ),
174       )
175       ->install_delayed
176       ->register_attribute_specs(%{$con?$con->all_attribute_specs:{}})
177   }
178 }
179
180 1;
181 =pod
182
183 =encoding utf-8
184
185 =head1 NAME
186
187 Moo - Minimalist Object Orientation (with Moose compatiblity)
188
189 =head1 SYNOPSIS
190
191  package Cat::Food;
192
193  use Moo;
194
195  sub feed_lion {
196    my $self = shift;
197    my $amount = shift || 1;
198
199    $self->pounds( $self->pounds - $amount );
200  }
201
202  has taste => (
203    is => 'ro',
204  );
205
206  has brand => (
207    is  => 'ro',
208    isa => sub {
209      die "Only SWEET-TREATZ supported!" unless $_[0] eq 'SWEET-TREATZ'
210    },
211 );
212
213  has pounds => (
214    is  => 'rw',
215    isa => sub { die "$_[0] is too much cat food!" unless $_[0] < 15 },
216  );
217
218  1;
219
220 And elsewhere:
221
222  my $full = Cat::Food->new(
223     taste  => 'DELICIOUS.',
224     brand  => 'SWEET-TREATZ',
225     pounds => 10,
226  );
227
228  $full->feed_lion;
229
230  say $full->pounds;
231
232 =head1 DESCRIPTION
233
234 This module is an extremely light-weight subset of L<Moose> optimised for
235 rapid startup and "pay only for what you use".
236
237 It also avoids depending on any XS modules to allow simple deployments.  The
238 name C<Moo> is based on the idea that it provides almost -- but not quite -- two
239 thirds of L<Moose>.
240
241 Unlike L<Mouse> this module does not aim at full compatibility with
242 L<Moose>'s surface syntax, preferring instead of provide full interoperability
243 via the metaclass inflation capabilities described in L</MOO AND MOOSE>.
244
245 For a full list of the minor differences between L<Moose> and L<Moo>'s surface
246 syntax, see L</INCOMPATIBILITIES WITH MOOSE>.
247
248 =head1 WHY MOO EXISTS
249
250 If you want a full object system with a rich Metaprotocol, L<Moose> is
251 already wonderful.
252
253 However, sometimes you're writing a command line script or a CGI script
254 where fast startup is essential, or code designed to be deployed as a single
255 file via L<App::FatPacker>, or you're writing a CPAN module and you want it
256 to be usable by people with those constraints.
257
258 I've tried several times to use L<Mouse> but it's 3x the size of Moo and
259 takes longer to load than most of my Moo based CGI scripts take to run.
260
261 If you don't want L<Moose>, you don't want "less metaprotocol" like L<Mouse>,
262 you want "as little as possible" -- which means "no metaprotocol", which is
263 what Moo provides.
264
265 Better still, if you install and load L<Moose>, we set up metaclasses for your
266 L<Moo> classes and L<Moo::Role> roles, so you can use them in L<Moose> code
267 without ever noticing that some of your codebase is using L<Moo>.
268
269 Hence, Moo exists as its name -- Minimal Object Orientation -- with a pledge
270 to make it smooth to upgrade to L<Moose> when you need more than minimal
271 features.
272
273 =head1 MOO AND MOOSE
274
275 If L<Moo> detects L<Moose> being loaded, it will automatically register
276 metaclasses for your L<Moo> and L<Moo::Role> packages, so you should be able
277 to use them in L<Moose> code without anybody ever noticing you aren't using
278 L<Moose> everywhere.
279
280 Extending a L<Moose> class or consuming a L<Moose::Role> will also work.
281
282 So will extending a L<Mouse> class or consuming a L<Mouse::Role> - but note
283 that we don't provide L<Mouse> metaclasses or metaroles so the other way
284 around doesn't work. This feature exists for L<Any::Moose> users porting to
285 L<Moo>; enabling L<Mouse> users to use L<Moo> classes is not a priority for us.
286
287 This means that there is no need for anything like L<Any::Moose> for Moo
288 code - Moo and Moose code should simply interoperate without problem. To
289 handle L<Mouse> code, you'll likely need an empty Moo role or class consuming
290 or extending the L<Mouse> stuff since it doesn't register true L<Moose>
291 metaclasses like L<Moo> does.
292
293 If you want types to be upgraded to the L<Moose> types, use
294 L<MooX::Types::MooseLike> and install the L<MooseX::Types> library to
295 match the L<MooX::Types::MooseLike> library you're using - L<Moo> will
296 load the L<MooseX::Types> library and use that type for the newly created
297 metaclass.
298
299 If you need to disable the metaclass creation, add:
300
301   no Moo::sification;
302
303 to your code before Moose is loaded, but bear in mind that this switch is
304 currently global and turns the mechanism off entirely so don't put this
305 in library code.
306
307 =head1 MOO VERSUS ANY::MOOSE
308
309 L<Any::Moose> will load L<Mouse> normally, and L<Moose> in a program using
310 L<Moose> - which theoretically allows you to get the startup time of L<Mouse>
311 without disadvantaging L<Moose> users.
312
313 Sadly, this doesn't entirely work, since the selection is load order dependent
314 - L<Moo>'s metaclass inflation system explained above in L</MOO AND MOOSE> is
315 significantly more reliable.
316
317 So if you want to write a CPAN module that loads fast or has only pure perl
318 dependencies but is also fully usable by L<Moose> users, you should be using
319 L<Moo>.
320
321 For a full explanation, see the article
322 L<http://shadow.cat/blog/matt-s-trout/moo-versus-any-moose> which explains
323 the differing strategies in more detail and provides a direct example of
324 where L<Moo> succeeds and L<Any::Moose> fails.
325
326 =head1 IMPORTED METHODS
327
328 =head2 new
329
330  Foo::Bar->new( attr1 => 3 );
331
332 or
333
334  Foo::Bar->new({ attr1 => 3 });
335
336 =head2 BUILDARGS
337
338  sub BUILDARGS {
339    my ( $class, @args ) = @_;
340
341    unshift @args, "attr1" if @args % 2 == 1;
342
343    return { @args };
344  };
345
346  Foo::Bar->new( 3 );
347
348 The default implementation of this method accepts a hash or hash reference of
349 named parameters. If it receives a single argument that isn't a hash reference
350 it throws an error.
351
352 You can override this method in your class to handle other types of options
353 passed to the constructor.
354
355 This method should always return a hash reference of named options.
356
357 =head2 BUILD
358
359 Define a C<BUILD> method on your class and the constructor will automatically
360 call the C<BUILD> method from parent down to child after the object has
361 been instantiated.  Typically this is used for object validation or possibly
362 logging.
363
364 =head2 DEMOLISH
365
366 If you have a C<DEMOLISH> method anywhere in your inheritance hierarchy,
367 a C<DESTROY> method is created on first object construction which will call
368 C<< $instance->DEMOLISH($in_global_destruction) >> for each C<DEMOLISH>
369 method from child upwards to parents.
370
371 Note that the C<DESTROY> method is created on first construction of an object
372 of your class in order to not add overhead to classes without C<DEMOLISH>
373 methods; this may prove slightly surprising if you try and define your own.
374
375 =head2 does
376
377  if ($foo->does('Some::Role1')) {
378    ...
379  }
380
381 Returns true if the object composes in the passed role.
382
383 =head1 IMPORTED SUBROUTINES
384
385 =head2 extends
386
387  extends 'Parent::Class';
388
389 Declares base class. Multiple superclasses can be passed for multiple
390 inheritance (but please use roles instead).
391
392 Calling extends more than once will REPLACE your superclasses, not add to
393 them like 'use base' would.
394
395 =head2 with
396
397  with 'Some::Role1';
398
399 or
400
401  with 'Some::Role1', 'Some::Role2';
402
403 Composes one or more L<Moo::Role> (or L<Role::Tiny>) roles into the current
404 class.  An error will be raised if these roles have conflicting methods.
405
406 =head2 has
407
408  has attr => (
409    is => 'ro',
410  );
411
412 Declares an attribute for the class.
413
414 The options for C<has> are as follows:
415
416 =over 2
417
418 =item * is
419
420 B<required>, may be C<ro>, C<lazy>, C<rwp> or C<rw>.
421
422 C<ro> generates an accessor that dies if you attempt to write to it - i.e.
423 a getter only - by defaulting C<reader> to the name of the attribute.
424
425 C<lazy> generates a reader like C<ro>, but also sets C<lazy> to 1 and
426 C<builder> to C<_build_${attribute_name}> to allow on-demand generated
427 attributes.  This feature was my attempt to fix my incompetence when
428 originally designing C<lazy_build>, and is also implemented by
429 L<MooseX::AttributeShortcuts>.
430
431 C<rwp> generates a reader like C<ro>, but also sets C<writer> to
432 C<_set_${attribute_name}> for attributes that are designed to be written
433 from inside of the class, but read-only from outside.
434 This feature comes from L<MooseX::AttributeShortcuts>.
435
436 C<rw> generates a normal getter/setter by defaulting C<accessor> to the
437 name of the attribute.
438
439 =item * isa
440
441 Takes a coderef which is meant to validate the attribute.  Unlike L<Moose>, Moo
442 does not include a basic type system, so instead of doing C<< isa => 'Num' >>,
443 one should do
444
445  isa => sub {
446    die "$_[0] is not a number!" unless looks_like_number $_[0]
447  },
448
449 L<Sub::Quote aware|/SUB QUOTE AWARE>
450
451 Since L<Moo> does B<not> run the C<isa> check before C<coerce> if a coercion
452 subroutine has been supplied, C<isa> checks are not structural to your code
453 and can, if desired, be omitted on non-debug builds (although if this results
454 in an uncaught bug causing your program to break, the L<Moo> authors guarantee
455 nothing except that you get to keep both halves).
456
457 If you want L<MooseX::Types> style named types, look at
458 L<MooX::Types::MooseLike>.
459
460 To cause your C<isa> entries to be automatically mapped to named
461 L<Moose::Meta::TypeConstraint> objects (rather than the default behaviour
462 of creating an anonymous type), set:
463
464   $Moo::HandleMoose::TYPE_MAP{$isa_coderef} = sub {
465     require MooseX::Types::Something;
466     return MooseX::Types::Something::TypeName();
467   };
468
469 Note that this example is purely illustrative; anything that returns a
470 L<Moose::Meta::TypeConstraint> object or something similar enough to it to
471 make L<Moose> happy is fine.
472
473 =item * coerce
474
475 Takes a coderef which is meant to coerce the attribute.  The basic idea is to
476 do something like the following:
477
478  coerce => sub {
479    $_[0] + 1 unless $_[0] % 2
480  },
481
482 Note that L<Moo> will always fire your coercion: this is to permit
483 C<isa> entries to be used purely for bug trapping, whereas coercions are
484 always structural to your code. We do, however, apply any supplied C<isa>
485 check after the coercion has run to ensure that it returned a valid value.
486
487 L<Sub::Quote aware|/SUB QUOTE AWARE>
488
489 =item * handles
490
491 Takes a string
492
493   handles => 'RobotRole'
494
495 Where C<RobotRole> is a role (L<Moo::Role>) that defines an interface which
496 becomes the list of methods to handle.
497
498 Takes a list of methods
499
500  handles => [ qw( one two ) ]
501
502 Takes a hashref
503
504  handles => {
505    un => 'one',
506  }
507
508 =item * trigger
509
510 Takes a coderef which will get called any time the attribute is set. This
511 includes the constructor. Coderef will be invoked against the object with the
512 new value as an argument.
513
514 If you set this to just C<1>, it generates a trigger which calls the
515 C<_trigger_${attr_name}> method on C<$self>. This feature comes from
516 L<MooseX::AttributeShortcuts>.
517
518 Note that Moose also passes the old value, if any; this feature is not yet
519 supported.
520
521 L<Sub::Quote aware|/SUB QUOTE AWARE>
522
523 =item * C<default>
524
525 Takes a coderef which will get called with $self as its only argument
526 to populate an attribute if no value is supplied to the constructor - or
527 if the attribute is lazy, when the attribute is first retrieved if no
528 value has yet been provided.
529
530 Note that if your default is fired during new() there is no guarantee that
531 other attributes have been populated yet so you should not rely on their
532 existence.
533
534 L<Sub::Quote aware|/SUB QUOTE AWARE>
535
536 =item * C<predicate>
537
538 Takes a method name which will return true if an attribute has a value.
539
540 If you set this to just C<1>, the predicate is automatically named
541 C<has_${attr_name}> if your attribute's name does not start with an
542 underscore, or <_has_${attr_name_without_the_underscore}> if it does.
543 This feature comes from L<MooseX::AttributeShortcuts>.
544
545 =item * C<builder>
546
547 Takes a method name which will be called to create the attribute - functions
548 exactly like default except that instead of calling
549
550   $default->($self);
551
552 Moo will call
553
554   $self->$builder;
555
556 If you set this to just C<1>, the predicate is automatically named
557 C<_build_${attr_name}>.  This feature comes from L<MooseX::AttributeShortcuts>.
558
559 =item * C<clearer>
560
561 Takes a method name which will clear the attribute.
562
563 If you set this to just C<1>, the clearer is automatically named
564 C<clear_${attr_name}> if your attribute's name does not start with an
565 underscore, or <_clear_${attr_name_without_the_underscore}> if it does.
566 This feature comes from L<MooseX::AttributeShortcuts>.
567
568 =item * C<lazy>
569
570 B<Boolean>.  Set this if you want values for the attribute to be grabbed
571 lazily.  This is usually a good idea if you have a L</builder> which requires
572 another attribute to be set.
573
574 =item * C<required>
575
576 B<Boolean>.  Set this if the attribute must be passed on instantiation.
577
578 =item * C<reader>
579
580 The value of this attribute will be the name of the method to get the value of
581 the attribute.  If you like Java style methods, you might set this to
582 C<get_foo>
583
584 =item * C<writer>
585
586 The value of this attribute will be the name of the method to set the value of
587 the attribute.  If you like Java style methods, you might set this to
588 C<set_foo>.
589
590 =item * C<weak_ref>
591
592 B<Boolean>.  Set this if you want the reference that the attribute contains to
593 be weakened; use this when circular references are possible, which will cause
594 leaks.
595
596 =item * C<init_arg>
597
598 Takes the name of the key to look for at instantiation time of the object.  A
599 common use of this is to make an underscored attribute have a non-underscored
600 initialization name. C<undef> means that passing the value in on instantiation
601 is ignored.
602
603 =back
604
605 =head2 before
606
607  before foo => sub { ... };
608
609 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
610 documentation.
611
612 =head2 around
613
614  around foo => sub { ... };
615
616 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
617 documentation.
618
619 =head2 after
620
621  after foo => sub { ... };
622
623 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
624 documentation.
625
626 =head1 SUB QUOTE AWARE
627
628 L<Sub::Quote/quote_sub> allows us to create coderefs that are "inlineable,"
629 giving us a handy, XS-free speed boost.  Any option that is L<Sub::Quote>
630 aware can take advantage of this.
631
632 To do this, you can write
633
634   use Moo;
635   use Sub::Quote;
636
637   has foo => (
638     is => 'ro',
639     isa => quote_sub(q{ die "Not <3" unless $_[0] < 3 })
640   );
641
642 which will be inlined as
643
644   do {
645     local @_ = ($_[0]->{foo});
646     die "Not <3" unless $_[0] < 3;
647   }
648
649 or to avoid localizing @_,
650
651   has foo => (
652     is => 'ro',
653     isa => quote_sub(q{ my ($val) = @_; die "Not <3" unless $val < 3 })
654   );
655
656 which will be inlined as
657
658   do {
659     my ($val) = ($_[0]->{foo});
660     die "Not <3" unless $val < 3;
661   }
662
663 See L<Sub::Quote> for more information, including how to pass lexical
664 captures that will also be compiled into the subroutine.
665
666 =head1 INCOMPATIBILITIES WITH MOOSE
667
668 There is no built-in type system.  C<isa> is verified with a coderef; if you
669 need complex types, just make a library of coderefs, or better yet, functions
670 that return quoted subs. L<MooX::Types::MooseLike> provides a similar API
671 to L<MooseX::Types::Moose> so that you can write
672
673   has days_to_live => (is => 'ro', isa => Int);
674
675 and have it work with both; it is hoped that providing only subrefs as an
676 API will encourage the use of other type systems as well, since it's
677 probably the weakest part of Moose design-wise.
678
679 C<initializer> is not supported in core since the author considers it to be a
680 bad idea but may be supported by an extension in future. Meanwhile C<trigger> or
681 C<coerce> are more likely to be able to fulfill your needs.
682
683 There is no meta object.  If you need this level of complexity you wanted
684 L<Moose> - Moo succeeds at being small because it explicitly does not
685 provide a metaprotocol. However, if you load L<Moose>, then
686
687   Class::MOP::class_of($moo_class_or_role)
688
689 will return an appropriate metaclass pre-populated by L<Moo>.
690
691 No support for C<super>, C<override>, C<inner>, or C<augment> - the author
692 considers augment to be a bad idea, and override can be translated:
693
694   override foo => sub {
695     ...
696     super();
697     ...
698   };
699
700   around foo => sub {
701     my ($orig, $self) = (shift, shift);
702     ...
703     $self->$orig(@_);
704     ...
705   };
706
707 The C<dump> method is not provided by default. The author suggests loading
708 L<Devel::Dwarn> into C<main::> (via C<perl -MDevel::Dwarn ...> for example) and
709 using C<$obj-E<gt>$::Dwarn()> instead.
710
711 L</default> only supports coderefs, because doing otherwise is usually a
712 mistake anyway.
713
714 C<lazy_build> is not supported; you are instead encouraged to use the
715 C<< is => 'lazy' >> option supported by L<Moo> and L<MooseX::AttributeShortcuts>.
716
717 C<auto_deref> is not supported since the author considers it a bad idea.
718
719 C<documentation> will show up in a L<Moose> metaclass created from your class
720 but is otherwise ignored. Then again, L<Moose> ignores it as well, so this
721 is arguably not an incompatibility.
722
723 Since C<coerce> does not require C<isa> to be defined but L<Moose> does
724 require it, the metaclass inflation for coerce alone is a trifle insane
725 and if you attempt to subtype the result will almost certainly break.
726
727 Handling of warnings: when you C<use Moo> we enable FATAL warnings.  The nearest
728 similar invocation for L<Moose> would be:
729
730   use Moose;
731   use warnings FATAL => "all";
732
733 Additionally, L<Moo> supports a set of attribute option shortcuts intended to
734 reduce common boilerplate.  The set of shortcuts is the same as in the L<Moose>
735 module L<MooseX::AttributeShortcuts> as of its version 0.009+.  So if you:
736
737     package MyClass;
738     use Moo;
739
740 The nearest L<Moose> invocation would be:
741
742     package MyClass;
743
744     use Moose;
745     use warnings FATAL => "all";
746     use MooseX::AttributeShortcuts;
747
748 or, if you're inheriting from a non-Moose class,
749
750     package MyClass;
751
752     use Moose;
753     use MooseX::NonMoose;
754     use warnings FATAL => "all";
755     use MooseX::AttributeShortcuts;
756
757 Finally, Moose requires you to call
758
759     __PACKAGE__->meta->make_immutable;
760
761 at the end of your class to get an inlined (i.e. not horribly slow)
762 constructor. Moo does it automatically the first time ->new is called
763 on your class.
764
765 =head1 SUPPORT
766
767 Users' IRC: #moose on irc.perl.org
768
769 Development and contribution IRC: #web-simple on irc.perl.org
770
771 =head1 AUTHOR
772
773 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
774
775 =head1 CONTRIBUTORS
776
777 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
778
779 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
780
781 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
782
783 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
784
785 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
786
787 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
788
789 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
790
791 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
792
793 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
794
795 Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
796
797 ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
798
799 tobyink - Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>
800
801 =head1 COPYRIGHT
802
803 Copyright (c) 2010-2011 the Moo L</AUTHOR> and L</CONTRIBUTORS>
804 as listed above.
805
806 =head1 LICENSE
807
808 This library is free software and may be distributed under the same terms
809 as perl itself.
810
811 =cut