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