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