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
 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 else where
 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 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 C<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 IMPORTED METHODS
 302
 303 =head2 new
 304
 305  Foo::Bar->new( attr1 => 3 );
 306
 307 or
 308
 309  Foo::Bar->new({ attr1 => 3 });
 310
 311 =head2 BUILDARGS
 312
 313  sub BUILDARGS {
 314    my ( $class, @args ) = @_;
 315
 316    unshift @args, "attr1" if @args % 2 == 1;
 317
 318    return { @args };
 319  };
 320
 321  Foo::Bar->new( 3 );
 322
 323 The default implementation of this method accepts a hash or hash reference of
 324 named parameters. If it receives a single argument that isn't a hash reference
 325 it throws an error.
 326
 327 You can override this method in your class to handle other types of options
 328 passed to the constructor.
 329
 330 This method should always return a hash reference of named options.
 331
 332 =head2 BUILD
 333
 334 Define a C<BUILD> method on your class and the constructor will automatically
 335 call the C<BUILD> method from parent down to child after the object has
 336 been instantiated.  Typically this is used for object validation or possibly
 337 logging.
 338
 339 =head2 DEMOLISH
 340
 341 If you have a C<DEMOLISH> method anywhere in your inheritance hierarchy,
 342 a C<DESTROY> method is created on first object construction which will call
 343 C<< $instance->DEMOLISH($in_global_destruction) >> for each C<DEMOLISH>
 344 method from child upwards to parents.
 345
 346 Note that the C<DESTROY> method is created on first construction of an object
 347 of your class in order to not add overhead to classes without C<DEMOLISH>
 348 methods; this may prove slightly surprising if you try and define your own.
 349
 350 =head2 does
 351
 352  if ($foo->does('Some::Role1')) {
 353    ...
 354  }
 355
 356 Returns true if the object composes in the passed role.
 357
 358 =head1 IMPORTED SUBROUTINES
 359
 360 =head2 extends
 361
 362  extends 'Parent::Class';
 363
 364 Declares base class. Multiple superclasses can be passed for multiple
 365 inheritance (but please use roles instead).
 366
 367 Calling extends more than once will REPLACE your superclasses, not add to
 368 them like 'use base' would.
 369
 370 =head2 with
 371
 372  with 'Some::Role1';
 373
 374 or
 375
 376  with 'Some::Role1', 'Some::Role2';
 377
 378 Composes one or more L<Moo::Role> (or L<Role::Tiny>) roles into the current
 379 class.  An error will be raised if these roles have conflicting methods.
 380
 381 =head2 has
 382
 383  has attr => (
 384    is => 'ro',
 385  );
 386
 387 Declares an attribute for the class.
 388
 389 The options for C<has> are as follows:
 390
 391 =over 2
 392
 393 =item * is
 394
 395 B<required>, may be C<ro>, C<lazy>, C<rwp> or C<rw>.
 396
 397 C<ro> generates an accessor that dies if you attempt to write to it - i.e.
 398 a getter only - by defaulting C<reader> to the name of the attribute.
 399
 400 C<lazy> generates a reader like C<ro>, but also sets C<lazy> to 1 and
 401 C<builder> to C<_build_${attribute_name}> to allow on-demand generated
 402 attributes.  This feature was my attempt to fix my incompetence when
 403 originally designing C<lazy_build>, and is also implemented by
 404 L<MooseX::AttributeShortcuts>.
 405
 406 C<rwp> generates a reader like C<ro>, but also sets C<writer> to
 407 C<_set_${attribute_name}> for attributes that are designed to be written
 408 from inside of the class, but read-only from outside.
 409 This feature comes from L<MooseX::AttributeShortcuts>.
 410
 411 C<rw> generates a normal getter/setter by defaulting C<accessor> to the
 412 name of the attribute.
 413
 414 =item * isa
 415
 416 Takes a coderef which is meant to validate the attribute.  Unlike L<Moose> Moo
 417 does not include a basic type system, so instead of doing C<< isa => 'Num' >>,
 418 one should do
 419
 420  isa => sub {
 421    die "$_[0] is not a number!" unless looks_like_number $_[0]
 422  },
 423
 424 L<Sub::Quote aware|/SUB QUOTE AWARE>
 425
 426 Since L<Moo> does B<not> run the C<isa> check before C<coerce> if a coercion
 427 subroutine has been supplied, C<isa> checks are not structural to your code
 428 and can, if desired, be omitted on non-debug builds (although if this results
 429 in an uncaught bug causing your program to break, the L<Moo> authors guarantee
 430 nothing except that you get to keep both halves).
 431
 432 If you want L<MooseX::Types> style named types, look at
 433 L<MooX::Types::MooseLike>.
 434
 435 To cause your C<isa> entries to be automatically mapped to named
 436 L<Moose::Meta::TypeConstraint> objects (rather than the default behaviour
 437 of creating an anonymous type), set:
 438
 439   $Moo::HandleMoose::TYPE_MAP{$isa_coderef} = sub {
 440     require MooseX::Types::Something;
 441     return MooseX::Types::Something::TypeName();
 442   };
 443
 444 Note that this example is purely illustrative; anything that returns a
 445 L<Moose::Meta::TypeConstraint> object or something similar enough to it to
 446 make L<Moose> happy is fine.
 447
 448 =item * coerce
 449
 450 Takes a coderef which is meant to coerce the attribute.  The basic idea is to
 451 do something like the following:
 452
 453  coerce => sub {
 454    $_[0] + 1 unless $_[0] % 2
 455  },
 456
 457 Note that L<Moo> will always fire your coercion - this is to permit
 458 isa entries to be used purely for bug trapping, whereas coercions are
 459 always structural to your code. We do, however, apply any supplied C<isa>
 460 check after the coercion has run to ensure that it returned a valid value.
 461
 462 L<Sub::Quote aware|/SUB QUOTE AWARE>
 463
 464 =item * handles
 465
 466 Takes a string
 467
 468   handles => 'RobotRole'
 469
 470 Where C<RobotRole> is a role (L<Moo::Role>) that defines an interface which
 471 becomes the list of methods to handle.
 472
 473 Takes a list of methods
 474
 475  handles => [ qw( one two ) ]
 476
 477 Takes a hashref
 478
 479  handles => {
 480    un => 'one',
 481  }
 482
 483 =item * trigger
 484
 485 Takes a coderef which will get called any time the attribute is set. This
 486 includes the constructor. Coderef will be invoked against the object with the
 487 new value as an argument.
 488
 489 If you set this to just C<1>, it generates a trigger which calls the
 490 C<_trigger_${attr_name}> method on C<$self>. This feature comes from
 491 L<MooseX::AttributeShortcuts>.
 492
 493 Note that Moose also passes the old value, if any; this feature is not yet
 494 supported.
 495
 496 L<Sub::Quote aware|/SUB QUOTE AWARE>
 497
 498 =item * default
 499
 500 Takes a coderef which will get called with $self as its only argument
 501 to populate an attribute if no value is supplied to the constructor - or
 502 if the attribute is lazy, when the attribute is first retrieved if no
 503 value has yet been provided.
 504
 505 Note that if your default is fired during new() there is no guarantee that
 506 other attributes have been populated yet so you should not rely on their
 507 existence.
 508
 509 L<Sub::Quote aware|/SUB QUOTE AWARE>
 510
 511 =item * predicate
 512
 513 Takes a method name which will return true if an attribute has a value.
 514
 515 If you set this to just C<1>, the predicate is automatically named
 516 C<has_${attr_name}> if your attribute's name does not start with an
 517 underscore, or <_has_${attr_name_without_the_underscore}> if it does.
 518 This feature comes from L<MooseX::AttributeShortcuts>.
 519
 520 =item * builder
 521
 522 Takes a method name which will be called to create the attribute - functions
 523 exactly like default except that instead of calling
 524
 525   $default->($self);
 526
 527 Moo will call
 528
 529   $self->$builder;
 530
 531 If you set this to just C<1>, the predicate is automatically named
 532 C<_build_${attr_name}>.  This feature comes from L<MooseX::AttributeShortcuts>.
 533
 534 =item * clearer
 535
 536 Takes a method name which will clear the attribute.
 537
 538 If you set this to just C<1>, the clearer is automatically named
 539 C<clear_${attr_name}> if your attribute's name does not start with an
 540 underscore, or <_clear_${attr_name_without_the_underscore}> if it does.
 541 This feature comes from L<MooseX::AttributeShortcuts>.
 542
 543 =item * lazy
 544
 545 B<Boolean>.  Set this if you want values for the attribute to be grabbed
 546 lazily.  This is usually a good idea if you have a L</builder> which requires
 547 another attribute to be set.
 548
 549 =item * required
 550
 551 B<Boolean>.  Set this if the attribute must be passed on instantiation.
 552
 553 =item * reader
 554
 555 The value of this attribute will be the name of the method to get the value of
 556 the attribute.  If you like Java style methods, you might set this to
 557 C<get_foo>
 558
 559 =item * writer
 560
 561 The value of this attribute will be the name of the method to set the value of
 562 the attribute.  If you like Java style methods, you might set this to
 563 C<set_foo>
 564
 565 =item * weak_ref
 566
 567 B<Boolean>.  Set this if you want the reference that the attribute contains to
 568 be weakened; use this when circular references are possible, which will cause
 569 leaks.
 570
 571 =item * init_arg
 572
 573 Takes the name of the key to look for at instantiation time of the object.  A
 574 common use of this is to make an underscored attribute have a non-underscored
 575 initialization name. C<undef> means that passing the value in on instantiation
 576 is ignored.
 577
 578 =back
 579
 580 =head2 before
 581
 582  before foo => sub { ... };
 583
 584 See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
 585 documentation.
 586
 587 =head2 around
 588
 589  around foo => sub { ... };
 590
 591 See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
 592 documentation.
 593
 594 =head2 after
 595
 596  after foo => sub { ... };
 597
 598 See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
 599 documentation.
 600
 601 =head1 SUB QUOTE AWARE
 602
 603 L<Sub::Quote/quote_sub> allows us to create coderefs that are "inlineable,"
 604 giving us a handy, XS-free speed boost.  Any option that is L<Sub::Quote>
 605 aware can take advantage of this.
 606
 607 To do this, you can write
 608
 609   use Moo;
 610   use Sub::Quote;
 611
 612   has foo => (
 613     is => quote_sub(q{ die "Not <3" unless $_[0] < 3 })
 614   );
 615
 616 which will be inlined as
 617
 618   do {
 619     local @_ = ($_[0]->{foo});
 620     die "Not <3" unless $_[0] < 3;
 621   }
 622
 623 or to avoid localizing @_,
 624
 625   has foo => (
 626     is => quote_sub(q{ my ($val) = @_; die "Not <3" unless $val < 3 })
 627   );
 628
 629 which will be inlined as
 630
 631   do {
 632     my ($val) = ($_[0]->{foo});
 633     die "Not <3" unless $val < 3;
 634   }
 635
 636 See L<Sub::Quote> for more information, including how to pass lexical
 637 captures that will also be compiled in to the subroutine.
 638
 639 =head1 INCOMPATIBILITIES WITH MOOSE
 640
 641 There is no built in type system.  C<isa> is verified with a coderef, if you
 642 need complex types, just make a library of coderefs, or better yet, functions
 643 that return quoted subs. L<MooX::Types::MooseLike> provides a similar API
 644 to L<MooseX::Types::Moose> so that you can write
 645
 646   has days_to_live => (is => 'ro', isa => Int);
 647
 648 and have it work with both; it is hoped that providing only subrefs as an
 649 API will encourage the use of other type systems as well, since it's
 650 probably the weakest part of Moose design-wise.
 651
 652 C<initializer> is not supported in core since the author considers it to be a
 653 bad idea but may be supported by an extension in future. Meanwhile C<trigger> or
 654 C<coerce> are more likely to be able to fulfill your needs.
 655
 656 There is no meta object.  If you need this level of complexity you wanted
 657 L<Moose> - Moo succeeds at being small because it explicitly does not
 658 provide a metaprotocol. However, if you load L<Moose>, then
 659
 660   Class::MOP::class_of($moo_class_or_role)
 661
 662 will return an appropriate metaclass pre-populated by L<Moo>.
 663
 664 No support for C<super>, C<override>, C<inner>, or C<augment> - the author
 665 considers augment to be a bad idea, and override can be translated:
 666
 667   override foo => sub {
 668     ...
 669     super();
 670     ...
 671   };
 672
 673   around foo => sub {
 674     my ($orig, $self) = (shift, shift);
 675     ...
 676     $self->$orig(@_);
 677     ...
 678   };
 679
 680 The C<dump> method is not provided by default. The author suggests loading
 681 L<Devel::Dwarn> into C<main::> (via C<perl -MDevel::Dwarn ...> for example) and
 682 using C<$obj-E<gt>$::Dwarn()> instead.
 683
 684 L</default> only supports coderefs, because doing otherwise is usually a
 685 mistake anyway.
 686
 687 C<lazy_build> is not supported; you are instead encouraged to use the
 688 C<is => 'lazy'> option supported by L<Moo> and L<MooseX::AttributeShortcuts>.
 689
 690 C<auto_deref> is not supported since the author considers it a bad idea.
 691
 692 C<documentation> will show up in a L<Moose> metaclass created from your class
 693 but is otherwise ignored. Then again, L<Moose> ignores it as well, so this
 694 is arguably not an incompatibility.
 695
 696 Since C<coerce> does not require C<isa> to be defined but L<Moose> does
 697 require it, the metaclass inflation for coerce-alone is a trifle insane
 698 and if you attempt to subtype the result will almost certainly break.
 699
 700 Handling of warnings: when you C<use Moo> we enable FATAL warnings.  The nearest
 701 similar invocation for L<Moose> would be:
 702
 703   use Moose;
 704   use warnings FATAL => "all";
 705
 706 Additionally, L<Moo> supports a set of attribute option shortcuts intended to
 707 reduce common boilerplate.  The set of shortcuts is the same as in the L<Moose>
 708 module L<MooseX::AttributeShortcuts> as of its version 0.009+.  So if you:
 709
 710     package MyClass;
 711     use Moo;
 712
 713 The nearest L<Moose> invocation would be:
 714
 715     package MyClass;
 716
 717     use Moose;
 718     use warnings FATAL => "all";
 719     use MooseX::AttributeShortcuts;
 720
 721 or, if you're inheriting from a non-Moose class,
 722
 723     package MyClass;
 724
 725     use Moose;
 726     use MooseX::NonMoose;
 727     use warnings FATAL => "all";
 728     use MooseX::AttributeShortcuts;
 729
 730 Finally, Moose requires you to call
 731
 732     __PACKAGE__->meta->make_immutable;
 733
 734 at the end of your class to get an inlined (i.e. not horribly slow)
 735 constructor. Moo does it automatically the first time ->new is called
 736 on your class.
 737
 738 =head1 SUPPORT
 739
 740 Users' IRC: #moose on irc.perl.org
 741
 742 Development and contribution IRC: #web-simple on irc.perl.org
 743
 744 =head1 AUTHOR
 745
 746 mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
 747
 748 =head1 CONTRIBUTORS
 749
 750 dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
 751
 752 frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
 753
 754 hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
 755
 756 jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
 757
 758 ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
 759
 760 chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
 761
 762 ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
 763
 764 doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
 765
 766 perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
 767
 768 Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
 769
 770 ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
 771
 772 =head1 COPYRIGHT
 773
 774 Copyright (c) 2010-2011 the Moo L</AUTHOR> and L</CONTRIBUTORS>
 775 as listed above.
 776
 777 =head1 LICENSE
 778
 779 This library is free software and may be distributed under the same terms
 780 as perl itself.
 781
 782 =cut