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