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