=head3 Is Moose "production ready"?
-Yes. I have two medium-to-large-ish web applications in
+Yes. I have several medium-to-large-ish web applications in
production using Moose, they have been running without
-issue now for almost a year.
+issue now for well over a year.
-At $work we are re-writing our core offering to use Moose,
+At C<$work> we are re-writing our core offering to use Moose,
so it's continued development is assured.
Several other people on #moose either have apps in production
available for getting the speed you need.
Currently we have the option of making your classes immutable
-as a means of boosting speed. This will mean a larger compile
+as a means of boosting speed. This will mean a slightly larger compile
time cost, but the runtime speed increase (especially in object
construction) is pretty significant. This is not very well
documented yet, so please ask on the list or on #moose for more
=head3 When will Moose 1.0 be ready?
-I had originally said it would be end of 2006, but various bits
-of $work kept me too busy. At this point, I think we are getting
-pretty close and I will likely declare 1.0 within the next few
-releases.
-
-When will that be? Hard to say really, but honestly, it is ready
-to use now, the difference between now and 1.0 will be pretty
-minimal.
+It is right now, I declared 0.18 to be "ready to use".
=head2 Constructors
If you need to affect the constructor's parameters prior to the
instance actually being constructed, you have a number of options.
-First, there are I<coercions> (See the L<Moose::Cookbook::Recipe5>
-for a complete example and explaination of coercions). With
-coercions it is possible to morph argument values into the correct
-expected types. This approach is the most flexible and robust, but
-does have a slightly higher learning curve.
+To change the parameter processing as a whole, you can use
+the C<BUILDARGS> method. The default implementation accepts key/value
+pairs or a hash reference. You can override it to take positional args,
+or any other format
-Second, using an C<around> method modifier on C<new> can be an
-effective way to affect the contents of C<@_> prior to letting
-Moose deal with it. This carries with it the extra burden for
-your subclasses, in that they have to be sure to explicitly
-call your C<new> and/or work around your C<new> to get to the
-version from L<Moose::Object>.
+To change the handling of individual parameters, there are I<coercions>
+(See the L<Moose::Cookbook::Basics::Recipe5> for a complete example and
+explaination of coercions). With coercions it is possible to morph
+argument values into the correct expected types. This approach is the
+most flexible and robust, but does have a slightly higher learning
+curve.
-The last approach is to use the standard Perl technique of calling
-the C<SUPER::new> within your own custom version of C<new>. This,
-of course, brings with it all the issues of the C<around> solution
-as well as any issues C<SUPER::> might add.
+=head3 How do I make non-Moose constructors work with Moose?
-In short, try to use C<BUILD> and coercions, they are your best
-bets.
+Usually the correct approach to subclassing a non Moose class is
+delegation. Moose makes this easy using the C<handles> keyword,
+coercions, and C<lazy_build>, so subclassing is often not the
+ideal route.
-=head3 How do I make non-Moose constructors work with Moose?
+That said, the default Moose constructor is inherited from
+L<Moose::Object>. When inheriting from a non-Moose class, the
+inheritance chain to L<Moose::Object> is broken. The simplest way
+to fix this is to simply explicitly inherit from L<Moose::Object>
+yourself.
-Moose provides its own constructor, but it does it by making all
-Moose-based classes inherit from L<Moose::Object>. When inheriting
-from a non-Moose class, the inheritance chain to L<Moose::Object>
-is broken. The simplest way to fix this is to simply explicitly
-inherit from L<Moose::Object> yourself. However, this does not
-always fix the issue of a constructor. Here is a basic example of
-how this can be worked around:
+However, this does not always fix the issue of actually calling the Moose
+constructor. Fortunately L<Class::MOP::Class/new_object>, the low level
+constructor, accepts the special C<__INSTANCE__> parameter, allowing you to
+instantiate your Moose attributes:
package My::HTML::Template;
use Moose;
return $class->meta->new_object(
# pass in the constructed object
# using the special key __INSTANCE__
- __INSTANCE__ => $obj, @_
+ __INSTANCE__ => $obj,
+ @_, # pass in the normal args
);
}
Of course, this only works if both your Moose class and the
inherited non-Moose class use the same instance type (typically
-HASH refs).
+HASH refs).
+
+Note that this doesn't call C<BUILDALL> automatically, you must do that
+yourself.
Other techniques can be used as well, such as creating the object
using C<Moose::Object::new>, but calling the inherited non-Moose
in the C<via> block.
For a more comprehensive example of using coercions, see the
-L<Moose::Cookbook::Recipe5>.
+L<Moose::Cookbook::Basics::Recipe5>.
If you need to deflate your attribute, the current best practice is to
add an C<around> modifier to your accessor. Here is some example code:
Not yet, but soon. This option will likely be coming in the next
release.
+=head2 Roles
+
+=head3 How do I get Moose to call BUILD in all my composed roles?
+
+See L<Moose::Cookbook::WTF> and specifically the B<How come BUILD
+is not called for my composed roles?> question in the B<Roles> section.
+
=head1 AUTHOR
Stevan Little E<lt>stevan@iinteractive.comE<gt>
=head1 COPYRIGHT AND LICENSE
-Copyright 2006, 2007 by Infinity Interactive, Inc.
+Copyright 2006-2008 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
-=cut
\ No newline at end of file
+=cut
projects / gitmo/Moose.git / blobdiff