[gitmo/Moose.git] / lib / Moose / Manual / Delta.pod

=pod

=head1 NAME

Moose::Manual::Delta - Important Changes in Moose

=head1 DESCRIPTION

This documents any important or noteworthy changes in Moose, with a
focus on backwards. This does duplicate data from the F<Changes> file,
but aims to provide more details and when possible workarounds.

Besides helping keep up with changes, you can also use this document
for finding the lowest version of Moose that supported a given
feature.  If you encounter a problem and have a solution but don't see
it documented here, or think we missed an important feature, please
send us a patch.

=head1 Version 0.89

L<Moose::Meta::Attribute::Native> has been moved into the Moose core from
L<MooseX::AttributeHelpers>.  Major changes include:

=over

=item C<traits>, not C<metaclass>

Method providers are only available via traits.

=item C<handles>, not C<provides> or C<curries>

The C<provides> syntax was like core Moose C<< handles => HASHREF >>
syntax, but with the keys and values reversed.  This was confusing,
and AttributeHelpers now uses C<< handles => HASHREF >> in a way that
should be intuitive to anyone already familiar with how it is used for
other attributes.

The C<curries> functionality provided by AttributeHelpers has been
generalized to apply to all cases of C<< handles => HASHREF >>, though
not every piece of functionality has been ported (currying with a
CODEREF is not supported).

=item C<empty> is now C<is_empty>, and means empty, not non-empty

Previously, the C<empty> method provided by Arrays and Hashes returned true if
the attribute was B<not> empty (no elements).  Now it returns true if the
attribute B<is> empty. It was also renamed to C<is_empty>, to reflect this.

=item C<find> was renamed to C<first>, and C<first> was renamed to C<head>

L<List::Util> refers to the functionality that we used to provide under C<find>
as L<first|List::Util/first>, so that will likely be more familiar (and will
fit in better if we decide to add more List::Util functions). C<head> is an
obvious choice to replace what used to be called C<first>.

=item Helpers that take a coderef of one argument now use C<$_>

Subroutines passed as the first argument to C<first>, C<map>, and C<grep> now
receive their argument in C<$_> rather than as a parameter to the subroutine.
Helpers that take a coderef of two or more arguments remain using the argument
list (there are technical limitations to using C<$a> and C<$b> like C<sort>
does).

=back

See L<Moose::Meta::Attribute::Native> for the new documentation.

C<< use Moose -metaclass => 'Foo' >> now does alias resolution, just like
C<-traits> (and the C<metaclass> and C<traits> options to C<has>).

Added two functions C<meta_class_alias> and C<meta_attribute_alias> to
L<Moose::Util>, to simplify aliasing metaclasses and metatraits. This is
a wrapper around the old

  package Moose::Meta::Class::Custom::Trait::FooTrait;
  sub register_implementation { 'My::Meta::Trait' }

way of doing this.

The C<alias> and C<excludes> role parameters have been renamed to C<-alias>
and C<-excludes>. The old names still work, but new code should use the new
names, and eventually the old ones will be deprecated and removed.

=head1 Version 0.84

When an attribute generates I<no> accessors, we now warn. This is to help
users who forget the C<is> option. If you really do not want any accessors,
you can use C<< is => 'bare' >>. You can maintain back compat with older
versions of Moose by using something like:

    ($Moose::VERSION >= 0.84 ? is => 'bare' : ())

When an accessor overwrites an existing method, we now warn. To work around
this warning (if you really must have this behavior), you can explicitly
remove the method before creating it as an accessor:

    sub foo {}

    __PACKAGE__->meta->remove_method('foo');

    has foo => (
        is => 'ro',
    );

When an unknown option is passed to C<has>, we now warn. You can silence
the warning by fixing your code. :)

The C<Role> type has been deprecated. On its own, it was useless,
since it just checked C<< $object->can('does') >>. If you were using
it as a parent type, just call C<role_type('Role::Name')> to create an
appropriate type instead.

=head1 Version 0.78

C<use Moose::Exporter;> now imports C<strict> and C<warnings> into packages
that use it.

=head1 Version 0.77

C<DEMOLISHALL> and C<DEMOLISH> now receive an argument indicating whether or
not we are in global destruction.

=head1 Version 0.76

Type constraints no longer run coercions for a value that already matches the
constraint.  This may affect some (arguably buggy) edge case coercions that
rely on side effects in the C<via> clause.

=head1 Version 0.75

L<Moose::Exporter> now accepts the C<-metaclass> option for easily
overriding the metaclass (without L<metaclass>). This works for classes
and roles.

=head1 Version 0.74

Added a C<duck_type> sugar function to L<Moose::Util::TypeConstraints>
to make integration with non-Moose classes easier. It simply checks if
C<< $obj->can() >> a list of methods.

A number of methods (mostly inherited from L<Class::MOP>) have been
renamed with a leading underscore to indicate their internal-ness. The
old method names will still work for a while, but will warn that the
method has been renamed. In a few cases, the method will be removed
entirely in the future. This may affect MooseX authors who were using
these methods.

=head1 Version 0.73

Calling C<subtype> with a name as the only argument now throws an
exception. If you want an anonymous subtype do:

    my $subtype = subtype as 'Foo';

This is related to the changes in version 0.71_01.

The C<is_needed> method in L<Moose::Meta::Method::Destructor> is now
only usable as a class method. Previously, it worked as a class or
object method, with a different internal implementation for each
version.

The internals of making a class immutable changed a lot in Class::MOP
0.78_02, and Moose's internals have changed along with it. The
external C<< $metaclass->make_immutable >> method still works the same
way.

=head1 Version 0.72

A mutable class accepted C<< Foo->new(undef) >> without complaint,
while an immutable class would blow up with an unhelpful error. Now,
in both cases we throw a helpful error instead.

This "feature" was originally added to allow for cases such as this:

  my $args;

  if ( something() ) {
      $args = {...};
  }

  return My::Class->new($args);

But we decided this is a bad idea and a little too magical, because it
can easily mask real errors.

=head1 Version 0.71_01

Calling C<type> or C<subtype> without the sugar helpers (C<as>,
C<where>, C<message>) is now deprecated.

As a side effect, this meant we ended up using Perl prototypes on
C<as>, and code like this will no longer work:

  use Moose::Util::TypeConstraints;
  use Declare::Constraints::Simple -All;

  subtype 'ArrayOfInts'
      => as 'ArrayRef'
      => IsArrayRef(IsInt);

Instead it must be changed to this:

  subtype(
      'ArrayOfInts' => {
          as    => 'ArrayRef',
          where => IsArrayRef(IsInt)
      }
  );

If you want to maintain backwards compat with older versions of Moose,
you must explicitly test Moose's C<VERSION>:

  if ( Moose->VERSION < 0.71_01 ) {
      subtype 'ArrayOfInts'
          => as 'ArrayRef'
          => IsArrayRef(IsInt);
  }
  else {
      subtype(
          'ArrayOfInts' => {
              as    => 'ArrayRef',
              where => IsArrayRef(IsInt)
          }
      );
  }

=head1 Version 0.70

We no longer pass the meta-attribute object as a final argument to
triggers. This actually changed for inlined code a while back, but the
non-inlined version and the docs were still out of date.

If by some chance you actually used this feature, the workaround is
simple. You fetch the attribute object from out of the C<$self>
that is passed as the first argument to trigger, like so:

  has 'foo' => (
      is      => 'ro',
      isa     => 'Any',
      trigger => sub {
          my ( $self, $value ) = @_;
          my $attr = $self->meta->find_attribute_by_name('foo');

          # ...
      }
  );

=head1 Version 0.66

If you created a subtype and passed a parent that Moose didn't know
about, it simply ignored the parent. Now it automatically creates the
parent as a class type. This may not be what you want, but is less
broken than before.

You could declare a name with subtype such as "Foo!Bar". Moose would
accept this allowed, but if you used it in a parameterized type such
as "ArrayRef[Foo!Bar]" it wouldn't work. We now do some vetting on
names created via the sugar functions, so that they can only contain
alphanumerics, ":", and ".".

=head1 Version 0.65

Methods created via an attribute can now fulfill a C<requires>
declaration for a role. Honestly we don't know why Stevan didn't make
this work originally, he was just insane or something.

Stack traces from inlined code will now report the line and file as
being in your class, as opposed to in Moose guts.

=head1 Version 0.62_02

When a class does not provide all of a role's required methods, the
error thrown now mentions all of the missing methods, as opposed to
just the first missing method.

Moose will no longer inline a constructor for your class unless it
inherits its constructor from Moose::Object, and will warn when it
doesn't inline. If you want to force inlining anyway, pass
C<< replace_constructor => 1 >> to C<make_immutable>.

If you want to get rid of the warning, pass C<< inline_constructor =>
0 >>.

=head1 Version 0.62

Removed the (deprecated) C<make_immutable> keyword.

Removing an attribute from a class now also removes delegation
(C<handles>) methods installed for that attribute. This is correct
behavior, but if you were wrongly relying on it you might get bit.

=head1 Version 0.58

Roles now add methods by calling C<add_method>, not
C<alias_method>. They make sure to always provide a method object,
which will be cloned internally. This means that it is now possible to
track the source of a method provided by a role, and even follow its
history through intermediate roles.  This means that methods added by
a role now show up when looking at a class's method list/map.

Parameter and Union args are now sorted, this makes Int|Str the same
constraint as Str|Int. Also, incoming type constraint strings are
normalized to remove all whitespace differences. This is mostly for
internals and should not affect outside code.

L<Moose::Exporter> will no longer remove a subroutine that the
exporting package re-exports. Moose re-exports the Carp::confess
function, among others. The reasoning is that we cannot know whether
you have also explicitly imported those functions for your own use, so
we err on the safe side and always keep them.

=head1 Version 0.56

C<Moose::init_meta> should now be called as a method.

New modules for extension writers, L<Moose::Exporter> and
L<Moose::Util::MetaRole>.

=head1 Version 0.55_01

Implemented metaclass traits (and wrote a recipe for it):

  use Moose -traits => 'Foo'

This should make writing small Moose extensions a little
easier.

=head1 Version 0.55

Fixed C<coerce> to accept anon types just like C<subtype> can.
So that you can do:

  coerce $some_anon_type => from 'Str' => via { ... };

=head1 Version 0.51

Added C<BUILDARGS>, a new step in C<< Moose::Object->new() >>.

=head1 Version 0.49

Fixed how the C<< is => (ro|rw) >> works with custom defined
C<reader>, C<writer> and C<accessor> options. See the below table for
details:

  is => ro, writer => _foo    # turns into (reader => foo, writer => _foo)
  is => rw, writer => _foo    # turns into (reader => foo, writer => _foo)
  is => rw, accessor => _foo  # turns into (accessor => _foo)
  is => ro, accessor => _foo  # error, accesor is rw

=head1 Version 0.45

The C<before/around/after> method modifiers now support regexp
matching of method names. NOTE: this only works for classes, it is
currently not supported in roles, but, ... patches welcome.

The C<has> keyword for roles now accepts the same array ref form that
L<Moose>.pm does for classes.

A trigger on a read-only attribute is no longer an error, as it's
useful to trigger off of the constructor.

Subtypes of parameterizable types now are parameterizable types
themselves.

=head1 Version 0.44

Fixed issue where C<DEMOLISHALL> was eating the value in C<$@>, and so
not working correctly. It still kind of eats them, but so does vanilla
perl.

=head1 Version 0.41

Inherited attributes may now be extended without restriction on the
type ('isa', 'does').

The entire set of Moose::Meta::TypeConstraint::* classes were
refactored in this release. If you were relying on their internals you
should test your code carefully.

=head1 Version 0.40

Documenting the use of '+name' with attributes that come from recently
composed roles. It makes sense, people are using it, and so why not
just officially support it.

The C<< Moose::Meta::Class->create >> method now supports roles.

It is now possible to make anonymous enum types by passing C<enum> an
array reference instead of the C<< enum $name => @values >>.

=head1 Version 0.37

Added the C<make_immutable> keyword as a shortcut to calling
C<make_immutable> on the meta object. This eventually got removed!

Made C<< init_arg => undef >> work in Moose. This means "do not accept
a constructor parameter for this attribute".

Type errors now use the provided message. Prior to this release they
didn't.

=head1 Version 0.34

Moose is now a postmodern object system :)

The Role system was completely refactored. It is 100% backwards
compat, but the internals were totally changed. If you relied on the
internals then you are advised to test carefully.

Added method exclusion and aliasing for Roles in this release.

Added the L<Moose::Util::TypeConstraints::OptimizedConstraints>
module.

Passing a list of values to an accessor (which is only expecting one
value) used to be silently ignored, now it throws an error.

=head1 Version 0.26

Added parameterized types and did a pretty heavy refactoring of the
type constraint system.

Better framework extendability and better support for "making your own
Moose".

=head1 Version 0.25 or before

Honestly, you shouldn't be using versions of Moose that are this old,
so many bug fixes and speed improvements have been made you would be
crazy to not upgrade.

Also, I am tired of going through the Changelog so I am stopping here,
if anyone would like to continue this please feel free.

=head1 AUTHOR

Stevan Little E<lt>stevan@iinteractive.comE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright 2009 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
Commit	Line	Data
600f7f85	1	=pod
	2
	3	=head1 NAME
	4
	5	Moose::Manual::Delta - Important Changes in Moose
	6
	7	=head1 DESCRIPTION
	8
0f13f53c	9	This documents any important or noteworthy changes in Moose, with a
	10	focus on backwards. This does duplicate data from the F<Changes> file,
	11	but aims to provide more details and when possible workarounds.
	12
	13	Besides helping keep up with changes, you can also use this document
	14	for finding the lowest version of Moose that supported a given
	15	feature. If you encounter a problem and have a solution but don't see
	16	it documented here, or think we missed an important feature, please
	17	send us a patch.
600f7f85	18
8a8856de	19	=head1 Version 0.89
a3d98218	20
af44c00c	21	L<Moose::Meta::Attribute::Native> has been moved into the Moose core from
a3d98218	22	L<MooseX::AttributeHelpers>. Major changes include:
	23
	24	=over
	25
	26	=item C<traits>, not C<metaclass>
	27
93ced2bd	28	Method providers are only available via traits.
a3d98218	29
	30	=item C<handles>, not C<provides> or C<curries>
	31
93ced2bd	32	The C<provides> syntax was like core Moose C<< handles => HASHREF >>
	33	syntax, but with the keys and values reversed. This was confusing,
	34	and AttributeHelpers now uses C<< handles => HASHREF >> in a way that
	35	should be intuitive to anyone already familiar with how it is used for
	36	other attributes.
a3d98218	37
93ced2bd	38	The C<curries> functionality provided by AttributeHelpers has been
	39	generalized to apply to all cases of C<< handles => HASHREF >>, though
	40	not every piece of functionality has been ported (currying with a
	41	CODEREF is not supported).
a3d98218	42
1853a27e	43	=item C<empty> is now C<is_empty>, and means empty, not non-empty
af44c00c	44
	45	Previously, the C<empty> method provided by Arrays and Hashes returned true if
	46	the attribute was B<not> empty (no elements). Now it returns true if the
1853a27e	47	attribute B<is> empty. It was also renamed to C<is_empty>, to reflect this.
af44c00c	48
28b96142	49	=item C<find> was renamed to C<first>, and C<first> was renamed to C<head>
	50
	51	L<List::Util> refers to the functionality that we used to provide under C<find>
	52	as L<first\|List::Util/first>, so that will likely be more familiar (and will
	53	fit in better if we decide to add more List::Util functions). C<head> is an
	54	obvious choice to replace what used to be called C<first>.
	55
	56	=item Helpers that take a coderef of one argument now use C<$_>
	57
	58	Subroutines passed as the first argument to C<first>, C<map>, and C<grep> now
	59	receive their argument in C<$_> rather than as a parameter to the subroutine.
	60	Helpers that take a coderef of two or more arguments remain using the argument
	61	list (there are technical limitations to using C<$a> and C<$b> like C<sort>
	62	does).
	63
a3d98218	64	=back
a3d98218	65
af44c00c	66	See L<Moose::Meta::Attribute::Native> for the new documentation.
a3d98218	67
8a8856de	68	C<< use Moose -metaclass => 'Foo' >> now does alias resolution, just like
	69	C<-traits> (and the C<metaclass> and C<traits> options to C<has>).
	70
27f2f43f	71	Added two functions C<meta_class_alias> and C<meta_attribute_alias> to
	72	L<Moose::Util>, to simplify aliasing metaclasses and metatraits. This is
	73	a wrapper around the old
	74
	75	package Moose::Meta::Class::Custom::Trait::FooTrait;
	76	sub register_implementation { 'My::Meta::Trait' }
	77
	78	way of doing this.
	79
c8b8d92f	80	The C<alias> and C<excludes> role parameters have been renamed to C<-alias>
	81	and C<-excludes>. The old names still work, but new code should use the new
	82	names, and eventually the old ones will be deprecated and removed.
	83
4831e2de	84	=head1 Version 0.84
4831e2de	85
9f52cce5	86	When an attribute generates I<no> accessors, we now warn. This is to help
9f52cce5	87	users who forget the C<is> option. If you really do not want any accessors,
3de02fd8	88	you can use C<< is => 'bare' >>. You can maintain back compat with older
	89	versions of Moose by using something like:
	90
	91	($Moose::VERSION >= 0.84 ? is => 'bare' : ())
9f52cce5	92
	93	When an accessor overwrites an existing method, we now warn. To work around
	94	this warning (if you really must have this behavior), you can explicitly
	95	remove the method before creating it as an accessor:
	96
	97	sub foo {}
	98
	99	__PACKAGE__->meta->remove_method('foo');
	100
	101	has foo => (
	102	is => 'ro',
	103	);
	104
	105	When an unknown option is passed to C<has>, we now warn. You can silence
	106	the warning by fixing your code. :)
	107
4831e2de	108	The C<Role> type has been deprecated. On its own, it was useless,
	109	since it just checked C<< $object->can('does') >>. If you were using
	110	it as a parent type, just call C<role_type('Role::Name')> to create an
	111	appropriate type instead.
	112
7d6b451f	113	=head1 Version 0.78
	114
	115	C<use Moose::Exporter;> now imports C<strict> and C<warnings> into packages
	116	that use it.
	117
c3fdacda	118	=head1 Version 0.77
	119
	120	C<DEMOLISHALL> and C<DEMOLISH> now receive an argument indicating whether or
	121	not we are in global destruction.
	122
00c61603	123	=head1 Version 0.76
00c61603	124
9f0b3b64	125	Type constraints no longer run coercions for a value that already matches the
	126	constraint. This may affect some (arguably buggy) edge case coercions that
	127	rely on side effects in the C<via> clause.
	128
f869fc4a	129	=head1 Version 0.75
	130
	131	L<Moose::Exporter> now accepts the C<-metaclass> option for easily
	132	overriding the metaclass (without L<metaclass>). This works for classes
	133	and roles.
	134
39ab7714	135	=head1 Version 0.74
39ab7714	136
85cf0647	137	Added a C<duck_type> sugar function to L<Moose::Util::TypeConstraints>
	138	to make integration with non-Moose classes easier. It simply checks if
	139	C<< $obj->can() >> a list of methods.
39ab7714	140
612fd754	141	A number of methods (mostly inherited from L<Class::MOP>) have been
	142	renamed with a leading underscore to indicate their internal-ness. The
	143	old method names will still work for a while, but will warn that the
	144	method has been renamed. In a few cases, the method will be removed
	145	entirely in the future. This may affect MooseX authors who were using
	146	these methods.
	147
600f7f85	148	=head1 Version 0.73
600f7f85	149
0f13f53c	150	Calling C<subtype> with a name as the only argument now throws an
600f7f85	151	exception. If you want an anonymous subtype do:
	152
	153	my $subtype = subtype as 'Foo';
	154
0f13f53c	155	This is related to the changes in version 0.71_01.
600f7f85	156
501db4e6	157	The C<is_needed> method in L<Moose::Meta::Method::Destructor> is now
	158	only usable as a class method. Previously, it worked as a class or
	159	object method, with a different internal implementation for each
	160	version.
	161
	162	The internals of making a class immutable changed a lot in Class::MOP
	163	0.78_02, and Moose's internals have changed along with it. The
	164	external C<< $metaclass->make_immutable >> method still works the same
	165	way.
	166
600f7f85	167	=head1 Version 0.72
600f7f85	168
0f13f53c	169	A mutable class accepted C<< Foo->new(undef) >> without complaint,
	170	while an immutable class would blow up with an unhelpful error. Now,
	171	in both cases we throw a helpful error instead.
600f7f85	172
0f13f53c	173	This "feature" was originally added to allow for cases such as this:
600f7f85	174
600f7f85	175	my $args;
0f13f53c	176
	177	if ( something() ) {
	178	$args = {...};
600f7f85	179	}
0f13f53c	180
600f7f85	181	return My::Class->new($args);
600f7f85	182
0f13f53c	183	But we decided this is a bad idea and a little too magical, because it
0f13f53c	184	can easily mask real errors.
600f7f85	185
	186	=head1 Version 0.71_01
	187
0f13f53c	188	Calling C<type> or C<subtype> without the sugar helpers (C<as>,
	189	C<where>, C<message>) is now deprecated.
	190
	191	As a side effect, this meant we ended up using Perl prototypes on
	192	C<as>, and code like this will no longer work:
600f7f85	193
	194	use Moose::Util::TypeConstraints;
	195	use Declare::Constraints::Simple -All;
0f13f53c	196
0f13f53c	197	subtype 'ArrayOfInts'
600f7f85	198	=> as 'ArrayRef'
	199	=> IsArrayRef(IsInt);
	200
	201	Instead it must be changed to this:
	202
0f13f53c	203	subtype(
	204	'ArrayOfInts' => {
	205	as => 'ArrayRef',
	206	where => IsArrayRef(IsInt)
	207	}
600f7f85	208	);
600f7f85	209
0f13f53c	210	If you want to maintain backwards compat with older versions of Moose,
0f13f53c	211	you must explicitly test Moose's C<VERSION>:
600f7f85	212
0f13f53c	213	if ( Moose->VERSION < 0.71_01 ) {
0f13f53c	214	subtype 'ArrayOfInts'
600f7f85	215	=> as 'ArrayRef'
	216	=> IsArrayRef(IsInt);
	217	}
	218	else {
0f13f53c	219	subtype(
	220	'ArrayOfInts' => {
	221	as => 'ArrayRef',
	222	where => IsArrayRef(IsInt)
	223	}
600f7f85	224	);
	225	}
	226
	227	=head1 Version 0.70
	228
0f13f53c	229	We no longer pass the meta-attribute object as a final argument to
	230	triggers. This actually changed for inlined code a while back, but the
	231	non-inlined version and the docs were still out of date.
	232
	233	If by some chance you actually used this feature, the workaround is
	234	simple. You fetch the attribute object from out of the C<$self>
	235	that is passed as the first argument to trigger, like so:
	236
	237	has 'foo' => (
	238	is => 'ro',
	239	isa => 'Any',
	240	trigger => sub {
	241	my ( $self, $value ) = @_;
	242	my $attr = $self->meta->find_attribute_by_name('foo');
	243
	244	# ...
	245	}
	246	);
600f7f85	247
	248	=head1 Version 0.66
	249
0f13f53c	250	If you created a subtype and passed a parent that Moose didn't know
	251	about, it simply ignored the parent. Now it automatically creates the
	252	parent as a class type. This may not be what you want, but is less
	253	broken than before.
600f7f85	254
0f13f53c	255	You could declare a name with subtype such as "Foo!Bar". Moose would
	256	accept this allowed, but if you used it in a parameterized type such
	257	as "ArrayRef[Foo!Bar]" it wouldn't work. We now do some vetting on
	258	names created via the sugar functions, so that they can only contain
	259	alphanumerics, ":", and ".".
600f7f85	260
	261	=head1 Version 0.65
	262
	263	Methods created via an attribute can now fulfill a C<requires>
0f13f53c	264	declaration for a role. Honestly we don't know why Stevan didn't make
0f13f53c	265	this work originally, he was just insane or something.
600f7f85	266
0f13f53c	267	Stack traces from inlined code will now report the line and file as
0f13f53c	268	being in your class, as opposed to in Moose guts.
600f7f85	269
	270	=head1 Version 0.62_02
	271
0f13f53c	272	When a class does not provide all of a role's required methods, the
	273	error thrown now mentions all of the missing methods, as opposed to
	274	just the first missing method.
600f7f85	275
0f13f53c	276	Moose will no longer inline a constructor for your class unless it
5e26e3f2	277	inherits its constructor from Moose::Object, and will warn when it
5e26e3f2	278	doesn't inline. If you want to force inlining anyway, pass
b84f64da	279	C<< replace_constructor => 1 >> to C<make_immutable>.
0f13f53c	280
0f13f53c	281	If you want to get rid of the warning, pass C<< inline_constructor =>
fbf7ba85	282	0 >>.
600f7f85	283
	284	=head1 Version 0.62
	285
0f13f53c	286	Removed the (deprecated) C<make_immutable> keyword.
600f7f85	287
600f7f85	288	Removing an attribute from a class now also removes delegation
0f13f53c	289	(C<handles>) methods installed for that attribute. This is correct
600f7f85	290	behavior, but if you were wrongly relying on it you might get bit.
	291
	292	=head1 Version 0.58
	293
0f13f53c	294	Roles now add methods by calling C<add_method>, not
	295	C<alias_method>. They make sure to always provide a method object,
	296	which will be cloned internally. This means that it is now possible to
	297	track the source of a method provided by a role, and even follow its
	298	history through intermediate roles. This means that methods added by
	299	a role now show up when looking at a class's method list/map.
	300
	301	Parameter and Union args are now sorted, this makes Int\|Str the same
	302	constraint as Str\|Int. Also, incoming type constraint strings are
	303	normalized to remove all whitespace differences. This is mostly for
	304	internals and should not affect outside code.
	305
	306	L<Moose::Exporter> will no longer remove a subroutine that the
	307	exporting package re-exports. Moose re-exports the Carp::confess
	308	function, among others. The reasoning is that we cannot know whether
	309	you have also explicitly imported those functions for your own use, so
	310	we err on the safe side and always keep them.
600f7f85	311
	312	=head1 Version 0.56
	313
0f13f53c	314	C<Moose::init_meta> should now be called as a method.
600f7f85	315
0f13f53c	316	New modules for extension writers, L<Moose::Exporter> and
0f13f53c	317	L<Moose::Util::MetaRole>.
600f7f85	318
	319	=head1 Version 0.55_01
	320
	321	Implemented metaclass traits (and wrote a recipe for it):
	322
	323	use Moose -traits => 'Foo'
	324
	325	This should make writing small Moose extensions a little
	326	easier.
	327
	328	=head1 Version 0.55
	329
	330	Fixed C<coerce> to accept anon types just like C<subtype> can.
	331	So that you can do:
	332
	333	coerce $some_anon_type => from 'Str' => via { ... };
	334
	335	=head1 Version 0.51
	336
52da380a	337	Added C<BUILDARGS>, a new step in C<< Moose::Object->new() >>.
600f7f85	338
	339	=head1 Version 0.49
	340
0f13f53c	341	Fixed how the C<< is => (ro\|rw) >> works with custom defined
0f13f53c	342	C<reader>, C<writer> and C<accessor> options. See the below table for
600f7f85	343	details:
	344
	345	is => ro, writer => _foo # turns into (reader => foo, writer => _foo)
	346	is => rw, writer => _foo # turns into (reader => foo, writer => _foo)
	347	is => rw, accessor => _foo # turns into (accessor => _foo)
	348	is => ro, accessor => _foo # error, accesor is rw
	349
	350	=head1 Version 0.45
	351
0f13f53c	352	The C<before/around/after> method modifiers now support regexp
	353	matching of method names. NOTE: this only works for classes, it is
	354	currently not supported in roles, but, ... patches welcome.
600f7f85	355
0f13f53c	356	The C<has> keyword for roles now accepts the same array ref form that
0f13f53c	357	L<Moose>.pm does for classes.
600f7f85	358
0f13f53c	359	A trigger on a read-only attribute is no longer an error, as it's
0f13f53c	360	useful to trigger off of the constructor.
600f7f85	361
0f13f53c	362	Subtypes of parameterizable types now are parameterizable types
0f13f53c	363	themselves.
600f7f85	364
	365	=head1 Version 0.44
	366
0f13f53c	367	Fixed issue where C<DEMOLISHALL> was eating the value in C<$@>, and so
	368	not working correctly. It still kind of eats them, but so does vanilla
	369	perl.
600f7f85	370
	371	=head1 Version 0.41
	372
0f13f53c	373	Inherited attributes may now be extended without restriction on the
600f7f85	374	type ('isa', 'does').
600f7f85	375
0f13f53c	376	The entire set of Moose::Meta::TypeConstraint::* classes were
	377	refactored in this release. If you were relying on their internals you
	378	should test your code carefully.
600f7f85	379
	380	=head1 Version 0.40
	381
0f13f53c	382	Documenting the use of '+name' with attributes that come from recently
	383	composed roles. It makes sense, people are using it, and so why not
	384	just officially support it.
600f7f85	385
0f13f53c	386	The C<< Moose::Meta::Class->create >> method now supports roles.
600f7f85	387
86b96832	388	It is now possible to make anonymous enum types by passing C<enum> an
86b96832	389	array reference instead of the C<< enum $name => @values >>.
600f7f85	390
	391	=head1 Version 0.37
	392
0f13f53c	393	Added the C<make_immutable> keyword as a shortcut to calling
0f13f53c	394	C<make_immutable> on the meta object. This eventually got removed!
600f7f85	395
0f13f53c	396	Made C<< init_arg => undef >> work in Moose. This means "do not accept
600f7f85	397	a constructor parameter for this attribute".
600f7f85	398
0f13f53c	399	Type errors now use the provided message. Prior to this release they
0f13f53c	400	didn't.
600f7f85	401
	402	=head1 Version 0.34
	403
	404	Moose is now a postmodern object system :)
	405
0f13f53c	406	The Role system was completely refactored. It is 100% backwards
	407	compat, but the internals were totally changed. If you relied on the
	408	internals then you are advised to test carefully.
600f7f85	409
	410	Added method exclusion and aliasing for Roles in this release.
	411
0f13f53c	412	Added the L<Moose::Util::TypeConstraints::OptimizedConstraints>
0f13f53c	413	module.
600f7f85	414
0f13f53c	415	Passing a list of values to an accessor (which is only expecting one
0f13f53c	416	value) used to be silently ignored, now it throws an error.
600f7f85	417
	418	=head1 Version 0.26
	419
0f13f53c	420	Added parameterized types and did a pretty heavy refactoring of the
0f13f53c	421	type constraint system.
600f7f85	422
0f13f53c	423	Better framework extendability and better support for "making your own
0f13f53c	424	Moose".
600f7f85	425
	426	=head1 Version 0.25 or before
	427
0f13f53c	428	Honestly, you shouldn't be using versions of Moose that are this old,
	429	so many bug fixes and speed improvements have been made you would be
	430	crazy to not upgrade.
600f7f85	431
0f13f53c	432	Also, I am tired of going through the Changelog so I am stopping here,
0f13f53c	433	if anyone would like to continue this please feel free.
600f7f85	434
	435	=head1 AUTHOR
	436
	437	Stevan Little E<lt>stevan@iinteractive.comE<gt>
	438
	439	=head1 COPYRIGHT AND LICENSE
	440
	441	Copyright 2009 by Infinity Interactive, Inc.
	442
	443	L<http://www.iinteractive.com>
	444
	445	This library is free software; you can redistribute it and/or modify
	446	it under the same terms as Perl itself.
	447
0f13f53c	448	=cut