{
    "content": [
        {
            "type": "text",
            "text": "# Moose::Manual::Delta (perldoc)\n\n## NAME\n\nMoose::Manual::Delta - Important Changes in Moose\n\n## DESCRIPTION\n\nThis documents any important or noteworthy changes in Moose, with a focus on things that affect\nbackwards compatibility. This does duplicate data from the Changes file, but aims to provide\nmore details and when possible workarounds.\n\n## Sections\n\n- **NAME**\n- **VERSION**\n- **DESCRIPTION**\n- **AUTHORS**\n- **COPYRIGHT AND LICENSE**\n\nUse structuredContent.sections for detailed options, examples, and full documentation.\n"
        }
    ],
    "structuredContent": {
        "command": "Moose::Manual::Delta",
        "section": "",
        "mode": "perldoc",
        "summary": "Moose::Manual::Delta - Important Changes in Moose",
        "synopsis": null,
        "tldr_summary": null,
        "tldr_examples": [],
        "tldr_source": null,
        "flags": [],
        "examples": [],
        "see_also": [],
        "section_outline": [
            {
                "name": "NAME",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "VERSION",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "DESCRIPTION",
                "lines": 905,
                "subsections": []
            },
            {
                "name": "AUTHORS",
                "lines": 20,
                "subsections": []
            },
            {
                "name": "COPYRIGHT AND LICENSE",
                "lines": 5,
                "subsections": []
            }
        ],
        "sections": {
            "NAME": {
                "content": "Moose::Manual::Delta - Important Changes in Moose\n",
                "subsections": []
            },
            "VERSION": {
                "content": "version 2.2200\n",
                "subsections": []
            },
            "DESCRIPTION": {
                "content": "This documents any important or noteworthy changes in Moose, with a focus on things that affect\nbackwards compatibility. This does duplicate data from the Changes file, but aims to provide\nmore details and when possible workarounds.\n\nBesides helping keep up with changes, you can also use this document for finding the lowest\nversion of Moose that supported a given feature. If you encounter a problem and have a solution\nbut don't see it documented here, or think we missed an important feature, please send us a\npatch.\n\n2.1400\nOverloading implementation has changed\nOverloading meta information used to be implemented by a \"Class::MOP::Method::Overload\"\nclass. This class has been removed, and overloading is now implemented by\nClass::MOP::Overload. Overloading is not really equivalent to a method, so the former\nimplementation didn't work properly for various cases.\n\nAll of the overloading-related methods for classes and roles have the same names, but those\nmethods now return Class::MOP::Overload objects.\n\nCore support for overloading in roles\nRoles which use overloading now pass that overloading onto other classes (and roles) which\nconsume that role.\n\nThis works much like MooseX::Role::WithOverloading, except that we properly detect\noverloading conflicts during role summation and when applying one role to another.\nMooseX::Role::WithOverloading did not do any conflict detection.\n\nIf you want to write code that uses overloading and works with previous versions of Moose\nand this one, upgrade to MooseX::Role::WithOverloading version 0.15 or greater. That version\nwill detect when Moose itself handles overloading and get out of the way.\n\n2.1200\nClasses created by Moose are now registered in %INC\nThis means that this will no longer die (and will also no longer try to load \"Foo.pm\"):\n\n{\npackage Foo;\nuse Moose;\n}\n\n# ...\n\nuse Foo;\n\nIf you're using the MOP, this behavior will occur when the \"create\" (or \"createanonclass\")\nmethod is used, but not when the \"initialize\" method is used.\n\nMoose now uses Module::Runtime instead of Class::Load to load classes\nClass::Load has always had some weird issues with the ways that it tries to figure out if a\nclass is loaded. For instance, extending an empty package was previously impossible, because\nClass::Load would think that the class failed to load, even though that is a perfectly valid\nthing to do. It was also difficult to deal with modules like IO::Handle, which partially\npopulate several other packages when they are loaded (so calling \"loadclass\" on\n'IO::Handle' followed by 'IO::File' could end up with a broken \"IO::File\", in some cases).\n\nNow, Moose uses the same mechanisms as perl itself to figure out if a class is loaded. A\nclass is considered to be loaded if its entry in %INC is set. Perl sets the %INC entry for\nyou automatically whenever a file is loaded via \"use\" or \"require\". Also, as mentioned\nabove, Moose also now sets the %INC entry for any classes defined with it, even if they\naren't loaded from a separate file. This does however mean that if you are trying to use\nMoose with non-Moose classes defined in the same file, then you will need to set %INC\nmanually now, where it may have worked in the past. For instance:\n\n{\npackage My::NonMoose;\n\nsub new { bless {}, shift }\n\n$INC{'My/NonMoose.pm'} = FILE;\n# alternatively:\n# use Module::Runtime 'modulenotionalfilename';\n# $INC{modulenotionalfilename(PACKAGE)} = FILE;\n}\n\n{\npackage My::Moose;\nuse Moose;\n\nextends 'My::NonMoose';\n}\n\nIf you don't do this, you will get an error message about not being able to locate\n\"My::NonMoose\" in @INC. We hope that this case will be fairly rare.\n\nThe Class::Load wrapper functions in Class::MOP have been deprecated\n\"Class::MOP::loadclass\", \"Class::MOP::isclassloaded\", and\n\"Class::MOP::loadfirstexistingclass\" have been deprecated. They have been undocumented\nand discouraged since version 2.0200. You should replace their use with the corresponding\nfunctions in Class::Load, or just use Module::Runtime directly.\n\nThe non-arrayref forms of \"enum\" and \"ducktype\" have been deprecated\nOriginally, \"enum\" could be called like this:\n\nenum('MyType' => qw(foo bar baz))\n\nThis was confusing, however (since it was different from the syntax for anonymous enum\ntypes), and it makes error checking more difficult (since you can't tell just by looking\nwhether \"enum('Foo', 'Bar', 'Baz')\" was intended to be a type named \"Foo\" with elements of\n\"Bar\" and \"Baz\", or if this was actually a mistake where someone got the syntax for an\nanonymous enum type wrong). This all also applies to \"ducktype\".\n\nCalling \"enum\" and \"ducktype\" with a list of arguments as described above has been\nundocumented since version 0.93, and is now deprecated. You should replace\n\nenum MyType => qw(foo bar baz);\n\nin your code with\n\nenum MyType => [qw(foo bar baz)];\n\nMoose string exceptions have been replaced by Moose exception objects\nPreviously, Moose threw string exceptions on error conditions, which were not so verbose.\nAll those string exceptions have now been converted to exception objects, which provide very\ndetailed information about the exceptions. These exception objects provide a string overload\nthat matches the previous exception message, so in most cases you should not have to change\nyour code.\n\nFor learning about the usage of Moose exception objects, read Moose::Manual::Exceptions.\nIndividual exceptions are documented in Moose::Manual::Exceptions::Manifest.\n\nThis work was funded as part of the GNOME Outreach Program for Women.\n\n2.1000\nThe Num type is now stricter\nThe \"Num\" type used to accept anything that fits Perl's notion of a number, which included\nInf, NaN, and strings like \" 1234 \\n\". We believe that the type constraint should indicate\n\"this is a number\", not \"this coerces to a number\". Therefore, Num now only accepts\nintegers, floating point numbers (both in decimal notation and exponential notation), 0, .0,\n0.0, etc.\n\nIf you want the old behavior you can use the \"LaxNum\" type in MooseX::Types::LaxNum.\n\nYou can use Specio instead of core Moose types\nThe Specio distribution is an experimental new type system intended to eventually replace\nthe core Moose types, but yet also work with things like Moo and Mouse and anything else.\nRight now this is all speculative, but at least you can use Specio with Moose.\n\n2.0600\n\"->initmeta\" is even less reliable at loading extensions\nPreviously, calling \"MooseX::Foo->initmeta(@)\" (and nothing else) from within your own\n\"initmeta\" had a decent chance of doing something useful. This was never supported\nbehavior, and didn't always work anyway. Due to some implementation adjustments, this now\nhas a smaller chance of doing something useful, which could break code that was expecting it\nto continue doing useful things. Code that does this should instead just call\n\"MooseX::Foo->import({ into => $into })\".\n\nAll the Cookbook recipes have been renamed\nWe've given them all descriptive names, rather than numbers. This makes it easier to talk\nabout them, and eliminates the need to renumber recipes in order to reorder them or delete\none.\n\n2.0400\nThe parent of a union type is its components' nearest common ancestor\nPreviously, union types considered all of their component types their parent types. This was\nincorrect because parent types are defined as types that must be satisfied in order for the\nchild type to be satisfied, but in a union, validating as any parent type will validate\nagainst the entire union. This has been changed to find the nearest common ancestor for all\nof its components. For example, a union of \"Int|ArrayRef[Int]\" now has a parent of\n\"Defined\".\n\nUnion types consider all members in the \"issubtypeof\" and \"isatypeof\" methods\nPreviously, a union type would report itself as being of a subtype of a type if *any* of its\nmember types were subtypes of that type. This was incorrect because any value that passes a\nsubtype constraint must also pass a parent constraint. This has changed so that *all* of its\nmember types must be a subtype of the specified type.\n\nEnum types now work with just one value\nPreviously, an \"enum\" type needed to have two or more values. Nobody knew why, so we fixed\nit.\n\nMethods defined in UNIVERSAL now appear in the MOP\nAny method introspection methods that look at methods from parent classes now find methods\ndefined in UNIVERSAL. This includes methods like \"$class->getallmethods\" and\n\"$class->findmethodbyname\".\n\nThis also means that you can now apply method modifiers to these methods.\n\nHand-optimized type constraint code causes a deprecation warning\nIf you provide an optimized sub ref for a type constraint, this now causes a deprecation\nwarning. Typically, this comes from passing an \"optimizeas\" parameter to \"subtype\", but it\ncould also happen if you create a Moose::Meta::TypeConstraint object directly.\n\nUse the inlining feature (\"inlineas\") added in 2.0100 instead.\n\n\"Class::Load::loadclass\" and \"isclassloaded\" have been removed\nThe \"Class::MOP::loadclass\" and \"Class::MOP::isclassloaded\" subroutines are no longer\ndocumented, and will cause a deprecation warning in the future. Moose now uses Class::Load\nto provide this functionality, and you should do so as well.\n\n2.0205\nArray and Hash native traits provide a \"shallowclone\" method\nThe Array and Hash native traits now provide a \"shallowclone\" method, which will return a\nreference to a new container with the same contents as the attribute's reference.\n\n2.0200\nHand-optimized type constraint code is deprecated in favor of inlining\nMoose allows you to provide a hand-optimized version of a type constraint's subroutine\nreference. This version allows type constraints to generate inline code, and you should use\nthis inlining instead of providing a hand-optimized subroutine reference.\n\nThis affects the \"optimizeas\" sub exported by Moose::Util::TypeConstraints. Use \"inlineas\"\ninstead.\n\nThis will start warning in the 2.0300 release.\n\n2.0002\nMore useful type constraint error messages\nIf you have Devel::PartialDump version 0.14 or higher installed, Moose's type constraint\nerror messages will use it to display the invalid value, rather than just displaying it\ndirectly. This will generally be much more useful. For instance, instead of this:\n\nAttribute (foo) does not pass the type constraint because: Validation failed for 'ArrayRef[Int]' with value ARRAY(0x275eed8)\n\nthe error message will instead look like\n\nAttribute (foo) does not pass the type constraint because: Validation failed for 'ArrayRef[Int]' with value [ \"a\" ]\n\nNote that Devel::PartialDump can't be made a direct dependency at the moment, because it\nuses Moose itself, but we're considering options to make this easier.\n\n2.0000\nRoles have their own default attribute metaclass\nPreviously, when a role was applied to a class, it would use the attribute metaclass defined\nin the class when copying over the attributes in the role. This was wrong, because for\ninstance, using MooseX::FollowPBP in the class would end up renaming all of the accessors\ngenerated by the role, some of which may be being called in the role, causing it to break.\nRoles now keep track of their own attribute metaclass to use by default when being applied\nto a class (defaulting to Moose::Meta::Attribute). This is modifiable using\nMoose::Util::MetaRole by passing the \"appliedattribute\" key to the \"rolemetaroles\" option,\nas in:\n\nMoose::Util::MetaRole::applymetaroles(\nfor => PACKAGE,\nclassmetaroles => {\nattribute => ['My::Meta::Role::Attribute'],\n},\nrolemetaroles => {\nappliedattribute => ['My::Meta::Role::Attribute'],\n},\n);\n\nClass::MOP has been folded into the Moose dist\nMoose and Class::MOP are tightly related enough that they have always had to be kept pretty\nclosely in step in terms of versions. Making them into a single dist should simplify the\nupgrade process for users, as it should no longer be possible to upgrade one without the\nother and potentially cause issues. No functionality has changed, and this should be\nentirely transparent.\n\nMoose's conflict checking is more robust and useful\nThere are two parts to this. The most useful one right now is that Moose will ship with a\n\"moose-outdated\" script, which can be run at any point to list the modules which are\ninstalled that conflict with the installed version of Moose. After upgrading Moose, running\n\"moose-outdated | cpanm\" should be sufficient to ensure that all of the Moose extensions you\nuse will continue to work.\n\nThe other part is that Moose's \"META.json\" file will also specify the conflicts under the\n\"xconflicts\" (now \"xbreaks\") key. We are working with the Perl tool chain developers to\ntry to get conflicts support added to CPAN clients, and if/when that happens, the metadata\nalready exists, and so the conflict checking will become automatic.\n\nThe lazybuild attribute feature is discouraged\nWhile not deprecated, we strongly discourage you from using this feature.\n\nMost deprecated APIs/features are slated for removal in Moose 2.0200\nMost of the deprecated APIs and features in Moose will start throwing an error in Moose\n2.0200. Some of the features will go away entirely, and some will simply throw an error.\n\nThe things on the chopping block are:\n\n*       Old public methods in Class::MOP and Moose\n\nThis includes things like \"Class::MOP::Class->getattributemap\",\n\"Class::MOP::Class->constructinstance\", and many others. These were deprecated in\nClass::MOP 0.8001, released on April 5, 2009.\n\nThese methods will be removed entirely in Moose 2.0200.\n\n*       Old public functions in Class::MOP\n\nThis include \"Class::MOP::subname\", \"Class::MOP::inglobaldestruction\", and the\n\"Class::MOP::HASISAREV\" constant. The first two were deprecated in 0.84, and the\nlast in 0.80. Class::MOP 0.84 was released on May 12, 2009.\n\nThese functions will be removed entirely in Moose 2.0200.\n\n*       The \"alias\" and \"excludes\" option for role composition\n\nThese were renamed to \"-alias\" and \"-excludes\" in Moose 0.89, released on August 13,\n2009.\n\nPassing these will throw an error in Moose 2.0200.\n\n*       The old Moose::Util::MetaRole API\n\nThis include the \"applymetaclassroles()\" function, as well as passing the\n\"forclass\" or any key ending in \"roles\" to \"applymetaroles()\". This was\ndeprecated in Moose 0.9301, released on January 4, 2010.\n\nThese will all throw an error in Moose 2.0200.\n\n*       Passing plain lists to \"type()\" or \"subtype()\"\n\nThe old API for these functions allowed you to pass a plain list of parameter,\nrather than a list of hash references (which is what \"as()\", \"where\", etc. return).\nThis was deprecated in Moose 0.7101, released on February 22, 2009.\n\nThis will throw an error in Moose 2.0200.\n\n*       The Role subtype\n\nThis subtype was deprecated in Moose 0.84, released on June 26, 2009.\n\nThis will be removed entirely in Moose 2.0200.\n\n1.21\n*   New release policy\n\nAs of the 2.0 release, Moose now has an official release and support policy, documented in\nMoose::Manual::Support. All API changes will now go through a deprecation cycle of at least\none year, after which the deprecated API can be removed. Deprecations and removals will only\nhappen in major releases.\n\nIn between major releases, we will still make minor releases to add new features, fix bugs,\nupdate documentation, etc.\n\n1.16\nConfigurable stacktraces\nClasses which use the Moose::Error::Default error class can now have stacktraces disabled by\nsetting the \"MOOSEERRORSTYLE\" env var to \"croak\". This is experimental, fairly incomplete,\nand won't work in all cases (because Moose's error system in general is all of these\nthings), but this should allow for reducing at least some of the verbosity in most cases.\n\n1.15\nNative Delegations\nIn previous versions of Moose, the Native delegations were created as closures. The\ngenerated code was often quite slow compared to doing the same thing by hand. For example,\nthe Array's push delegation ended up doing something like this:\n\npush @{ $self->$reader() }, @;\n\nIf the attribute was created without a reader, the $reader sub reference followed a very\nslow code path. Even with a reader, this is still slower than it needs to be.\n\nNative delegations are now generated as inline code, just like other accessors, so we can\naccess the slot directly.\n\nIn addition, native traits now do proper constraint checking in all cases. In particular,\nconstraint checking has been improved for array and hash references. Previously, only the\n*contained* type (the \"Str\" in \"HashRef[Str]\") would be checked when a new value was added\nto the collection. However, if there was a constraint that applied to the whole value, this\nwas never checked.\n\nIn addition, coercions are now called on the whole value.\n\nThe delegation methods now do more argument checking. All of the methods check that a valid\nnumber of arguments were passed to the method. In addition, the delegation methods check\nthat the arguments are sane (array indexes, hash keys, numbers, etc.) when applicable. We\nhave tried to emulate the behavior of Perl builtins as much as possible.\n\nFinally, triggers are called whenever the value of the attribute is changed by a Native\ndelegation.\n\nThese changes are only likely to break code in a few cases.\n\nThe inlining code may or may not preserve the original reference when changes are made. In\nsome cases, methods which change the value may replace it entirely. This will break tied\nvalues.\n\nIf you have a typed arrayref or hashref attribute where the type enforces a constraint on\nthe whole collection, this constraint will now be checked. It's possible that code which\npreviously ran without errors will now cause the constraint to fail. However, presumably\nthis is a good thing ;)\n\nIf you are passing invalid arguments to a delegation which were previously being ignored,\nthese calls will now fail.\n\nIf your code relied on the trigger only being called for a regular writer, that may cause\nproblems.\n\nAs always, you are encouraged to test before deploying the latest version of Moose to\nproduction.\n\nDefaults is and default for String, Counter, and Bool\nA few native traits (String, Counter, Bool) provide default values of \"is\" and \"default\"\nwhen you created an attribute. Allowing them to provide these values is now deprecated.\nSupply the value yourself when creating the attribute.\n\nThe \"meta\" method\nMoose and Class::MOP have been cleaned up internally enough to make the \"meta\" method that\nyou get by default optional. \"use Moose\" and \"use Moose::Role\" now can take an additional\n\"-metaname\" option, which tells Moose what name to use when installing the \"meta\" method.\nPassing \"undef\" to this option suppresses generation of the \"meta\" method entirely. This\nshould be useful for users of modules which also use a \"meta\" method or function, such as\nCurses or Rose::DB::Object.\n\n1.09\nAll deprecated features now warn\nPreviously, deprecation mostly consisted of simply saying \"X is deprecated\" in the Changes\nfile. We were not very consistent about actually warning. Now, all deprecated features still\npresent in Moose actually give a warning. The warning is issued once per calling package.\nSee Moose::Deprecated for more details.\n\nYou cannot pass \"coerce => 1\" unless the attribute's type constraint has a coercion\nPreviously, this was accepted, and it sort of worked, except that if you attempted to set\nthe attribute after the object was created, you would get a runtime error.\n\nNow you will get a warning when you attempt to define the attribute.\n\n\"no Moose\", \"no Moose::Role\", and \"no Moose::Exporter\" no longer unimport strict and warnings\nThis change was made in 1.05, and has now been reverted. We don't know if the user has\nexplicitly loaded strict or warnings on their own, and unimporting them is just broken in\nthat case.\n\nReversed logic when defining which options can be changed\nMoose::Meta::Attribute now allows all options to be changed in an overridden attribute. The\nprevious behaviour required each option to be whitelisted using the\n\"legaloptionsforinheritance\" method. This method has been removed, and there is a new\nmethod, \"illegaloptionsforinheritance\", which can now be used to prevent certain options\nfrom being changeable.\n\nIn addition, we only throw an error if the illegal option is actually changed. If the\nsuperclass didn't specify this option at all when defining the attribute, the subclass\nversion can still add it as an option.\n\nExample of overriding this in an attribute trait:\n\npackage Bar::Meta::Attribute;\nuse Moose::Role;\n\nhas 'myillegaloption' => (\nisa => 'CodeRef',\nis  => 'rw',\n);\n\naround illegaloptionsforinheritance => sub {\nreturn ( shift->(@), qw/myillegaloption/ );\n};\n\n1.05\n\"BUILD\" in Moose::Object methods are now called when calling \"newobject\"\nPreviously, \"BUILD\" methods would only be called from \"Moose::Object::new\", but now they are\nalso called when constructing an object via \"Moose::Meta::Class::newobject\". \"BUILD\"\nmethods are an inherent part of the object construction process, and this should make\n\"$meta->newobject\" actually usable without forcing people to use \"$meta->name->new\".\n\n\"no Moose\", \"no Moose::Role\", and \"no Moose::Exporter\" now unimport strict and warnings\nIn the interest of having \"no Moose\" clean up everything that \"use Moose\" does in the\ncalling scope, \"no Moose\" (as well as all other Moose::Exporter-using modules) now unimports\nstrict and warnings.\n\nMetaclass compatibility checking and fixing should be much more robust\nThe metaclass compatibility checking and fixing algorithms have been completely rewritten,\nin both Class::MOP and Moose. This should resolve many confusing errors when dealing with\nnon-Moose inheritance and with custom metaclasses for things like attributes, constructors,\netc. For correct code, the only thing that should require a change is that custom error\nmetaclasses must now inherit from Moose::Error::Default.\n\n1.02\nMoose::Meta::TypeConstraint::Class issubtypeof behavior\nEarlier versions of issubtypeof would incorrectly return true when called with itself, its\nown TC name or its class name as an argument. (i.e. $footc->issubtypeof('Foo') == 1) This\nbehavior was a caused by \"isa\" being checked before the class name. The old behavior can be\naccessed with istypeof\n\n1.00\nMoose::Meta::Attribute::Native::Trait::Code no longer creates reader methods by default\nEarlier versions of Moose::Meta::Attribute::Native::Trait::Code created read-only accessors\nfor the attributes it's been applied to, even if you didn't ask for it with \"is => 'ro'\".\nThis incorrect behaviour has now been fixed.\n\n0.95\nMoose::Util addmethodmodifier behavior\naddmethodmodifier (and subsequently the sugar functions Moose::before, Moose::after, and\nMoose::around) can now accept arrayrefs, with the same behavior as lists. Types other than\narrayref and regexp result in an error.\n\n0.9301 and 0.94\nMoose::Util::MetaRole API has changed\nThe \"applymetaclassroles\" function is now called \"applymetaroles\". The way arguments are\nsupplied has been changed to force you to distinguish between metaroles applied to\nMoose::Meta::Class (and helpers) versus Moose::Meta::Role.\n\nThe old API still works, but will warn in a future release, and eventually be removed.\n\nMoose::Meta::Role has real attributes\nThe attributes returned by Moose::Meta::Role are now instances of the\nMoose::Meta::Role::Attribute class, instead of bare hash references.\n\n\"no Moose\" now removes \"blessed\" and \"confess\"\nMoose is now smart enough to know exactly what it exported, even when it re-exports\nfunctions from other packages. When you unimport Moose, it will remove these functions from\nyour namespace unless you *also* imported them directly from their respective packages.\n\nIf you have a \"no Moose\" in your code *before* you call \"blessed\" or \"confess\", your code\nwill break. You can either move the \"no Moose\" call later in your code, or explicitly import\nthe relevant functions from the packages that provide them.\n\nMoose::Exporter is smarter about unimporting re-exports\nThe change above comes from a general improvement to Moose::Exporter. It will now unimport\nany function it exports, even if that function is a re-export from another package.\n\nAttributes in roles can no longer override class attributes with \"+foo\"\nPreviously, this worked more or less accidentally, because role attributes weren't objects.\nThis was never documented, but a few MooseX modules took advantage of this.\n\nThe compositionclassroles attribute in Moose::Meta::Role is now a method\nThis was done to make it possible for roles to alter the list of composition class roles by\napplying a method modifiers. Previously, this was an attribute and MooseX modules override\nit. Since that no longer works, this was made a method.\n\nThis *should* be an attribute, so this may switch back to being an attribute in the future\nif we can figure out how to make this work.\n\n0.93\nCalling $object->new() is no longer deprecated\nWe decided to undeprecate this. Now it just works.\n\nBoth \"getmethodmap\" and \"getattributemap\" is deprecated\nThese metaclass methods were never meant to be public, and they are both now deprecated. The\nwork around if you still need the functionality they provided is to iterate over the list of\nnames manually.\n\nmy %fields = map { $ => $meta->getattribute($) } $meta->getattributelist;\n\nThis was actually a change in Class::MOP, but this version of Moose requires a version of\nClass::MOP that includes said change.\n\n0.90\nAdded Native delegation for Code refs\nSee Moose::Meta::Attribute::Native::Trait::Code for details.\n\nCalling $object->new() is deprecated\nMoose has long supported this, but it's never really been documented, and we don't think\nthis is a good practice. If you want to construct an object from an existing object, you\nshould provide some sort of alternate constructor like \"$object->clone\".\n\nCalling \"$object->new\" now issues a warning, and will be an error in a future release.\n\nMoose no longer warns if you call \"makeimmutable\" for a class with mutable ancestors\nWhile in theory this is a good thing to warn about, we found so many exceptions to this that\ndoing this properly became quite problematic.\n\n0.8902\nNew Native delegation methods from List::Util and List::MoreUtils\nIn particular, we now have \"reduce\", \"shuffle\", \"uniq\", and \"natatime\".\n\nThe Moose::Exporter withcaller feature is now deprecated\nUse \"withmeta\" instead. The \"withcaller\" option will start warning in a future release.\n\nMoose now warns if you call \"makeimmutable\" for a class with mutable ancestors\nThis is dangerous because modifying a class after a subclass has been immutabilized will\nlead to incorrect results in the subclass, due to inlining, caching, etc. This occasionally\nhappens accidentally, when a class loads one of its subclasses in the middle of its class\ndefinition, so pointing out that this may cause issues should be helpful. Metaclasses\n(classes that inherit from Class::MOP::Object) are currently exempt from this check, since\nat the moment we aren't very consistent about which metaclasses we immutabilize.\n\n\"enum\" and \"ducktype\" now take arrayrefs for all forms\nPreviously, calling these functions with a list would take the first element of the list as\nthe type constraint name, and use the remainder as the enum values or method names. This\nmakes the interface inconsistent with the anon-type forms of these functions (which must\ntake an arrayref), and a free-form list where the first value is sometimes special is hard\nto validate (and harder to give reasonable error messages for). These functions have been\nchanged to take arrayrefs in all their forms - so, \"enum 'My::Type' => [qw(foo bar)]\" is now\nthe preferred way to create an enum type constraint. The old syntax still works for now, but\nit will hopefully be deprecated and removed in a future release.\n\n0.8901\nMoose::Meta::Attribute::Native has been moved into the Moose core from MooseX::AttributeHelpers.\nMajor changes include:\n\n\"traits\", not \"metaclass\"\nMethod providers are only available via traits.\n\n\"handles\", not \"provides\" or \"curries\"\nThe \"provides\" syntax was like core Moose \"handles => HASHREF\" syntax, but with the keys and\nvalues reversed. This was confusing, and AttributeHelpers now uses \"handles => HASHREF\" in a\nway that should be intuitive to anyone already familiar with how it is used for other\nattributes.\n\nThe \"curries\" functionality provided by AttributeHelpers has been generalized to apply to\nall cases of \"handles => HASHREF\", though not every piece of functionality has been ported\n(currying with a CODEREF is not supported).\n\n\"empty\" is now \"isempty\", and means empty, not non-empty\nPreviously, the \"empty\" method provided by Arrays and Hashes returned true if the attribute\nwas not empty (no elements). Now it returns true if the attribute is empty. It was also\nrenamed to \"isempty\", to reflect this.\n\n\"find\" was renamed to \"first\", and \"first\" and \"last\" were removed\nList::Util refers to the functionality that we used to provide under \"find\" as first, so\nthat will likely be more familiar (and will fit in better if we decide to add more\nList::Util functions). \"first\" and \"last\" were removed, since their functionality is easily\nduplicated with curries of \"get\".\n\nHelpers that take a coderef of one argument now use $\nSubroutines passed as the first argument to \"first\", \"map\", and \"grep\" now receive their\nargument in $ rather than as a parameter to the subroutine. Helpers that take a coderef of\ntwo or more arguments remain using the argument list (there are technical limitations to\nusing $a and $b like \"sort\" does).\n\nSee Moose::Meta::Attribute::Native for the new documentation.\n\nThe \"alias\" and \"excludes\" role parameters have been renamed to \"-alias\" and \"-excludes\". The\nold names still work, but new code should use the new names, and eventually the old ones will be\ndeprecated and removed.\n\n0.89\n\"use Moose -metaclass => 'Foo'\" now does alias resolution, just like \"-traits\" (and the\n\"metaclass\" and \"traits\" options to \"has\").\n\nAdded two functions \"metaclassalias\" and \"metaattributealias\" to Moose::Util, to simplify\naliasing metaclasses and metatraits. This is a wrapper around the old\n\npackage Moose::Meta::Class::Custom::Trait::FooTrait;\nsub registerimplementation { 'My::Meta::Trait' }\n\nway of doing this.\n\n0.84\nWhen an attribute generates *no* accessors, we now warn. This is to help users who forget the\n\"is\" option. If you really do not want any accessors, you can use \"is => 'bare'\". You can\nmaintain back compat with older versions of Moose by using something like:\n\n($Moose::VERSION >= 0.84 ? is => 'bare' : ())\n\nWhen an accessor overwrites an existing method, we now warn. To work around this warning (if you\nreally must have this behavior), you can explicitly remove the method before creating it as an\naccessor:\n\nsub foo {}\n\nPACKAGE->meta->removemethod('foo');\n\nhas foo => (\nis => 'ro',\n);\n\nWhen an unknown option is passed to \"has\", we now warn. You can silence the warning by fixing\nyour code. :)\n\nThe \"Role\" type has been deprecated. On its own, it was useless, since it just checked\n\"$object->can('does')\". If you were using it as a parent type, just call\n\"roletype('Role::Name')\" to create an appropriate type instead.\n\n0.78\n\"use Moose::Exporter;\" now imports \"strict\" and \"warnings\" into packages that use it.\n\n0.77\n\"DEMOLISHALL\" and \"DEMOLISH\" now receive an argument indicating whether or not we are in global\ndestruction.\n\n0.76\nType constraints no longer run coercions for a value that already matches the constraint. This\nmay affect some (arguably buggy) edge case coercions that rely on side effects in the \"via\"\nclause.\n\n0.75\nMoose::Exporter now accepts the \"-metaclass\" option for easily overriding the metaclass (without\nmetaclass). This works for classes and roles.\n\n0.74\nAdded a \"ducktype\" sugar function to Moose::Util::TypeConstraints to make integration with\nnon-Moose classes easier. It simply checks if \"$obj->can()\" a list of methods.\n\nA number of methods (mostly inherited from Class::MOP) have been renamed with a leading\nunderscore to indicate their internal-ness. The old method names will still work for a while,\nbut will warn that the method has been renamed. In a few cases, the method will be removed\nentirely in the future. This may affect MooseX authors who were using these methods.\n\n0.73\nCalling \"subtype\" with a name as the only argument now throws an exception. If you want an\nanonymous subtype do:\n\nmy $subtype = subtype as 'Foo';\n\nThis is related to the changes in version 0.7101.\n\nThe \"isneeded\" method in Moose::Meta::Method::Destructor is now only usable as a class method.\nPreviously, it worked as a class or object method, with a different internal implementation for\neach version.\n\nThe internals of making a class immutable changed a lot in Class::MOP 0.7802, and Moose's\ninternals have changed along with it. The external \"$metaclass->makeimmutable\" method still\nworks the same way.\n\n0.72\nA mutable class accepted \"Foo->new(undef)\" without complaint, while an immutable class would\nblow up with an unhelpful error. Now, in both cases we throw a helpful error instead.\n\nThis \"feature\" was originally added to allow for cases such as this:\n\nmy $args;\n\nif ( something() ) {\n$args = {...};\n}\n\nreturn My::Class->new($args);\n\nBut we decided this is a bad idea and a little too magical, because it can easily mask real\nerrors.\n\n0.7101\nCalling \"type\" or \"subtype\" without the sugar helpers (\"as\", \"where\", \"message\") is now\ndeprecated.\n\nAs a side effect, this meant we ended up using Perl prototypes on \"as\", and code like this will\nno longer work:\n\nuse Moose::Util::TypeConstraints;\nuse Declare::Constraints::Simple -All;\n\nsubtype 'ArrayOfInts'\n=> as 'ArrayRef'\n=> IsArrayRef(IsInt);\n\nInstead it must be changed to this:\n\nsubtype(\n'ArrayOfInts' => {\nas    => 'ArrayRef',\nwhere => IsArrayRef(IsInt)\n}\n);\n\nIf you want to maintain backwards compat with older versions of Moose, you must explicitly test\nMoose's \"VERSION\":\n\nif ( Moose->VERSION < 0.7101 ) {\nsubtype 'ArrayOfInts'\n=> as 'ArrayRef'\n=> IsArrayRef(IsInt);\n}\nelse {\nsubtype(\n'ArrayOfInts' => {\nas    => 'ArrayRef',\nwhere => IsArrayRef(IsInt)\n}\n);\n}\n\n0.70\nWe no longer pass the meta-attribute object as a final argument to triggers. This actually\nchanged for inlined code a while back, but the non-inlined version and the docs were still out\nof date.\n\nIf by some chance you actually used this feature, the workaround is simple. You fetch the\nattribute object from out of the $self that is passed as the first argument to trigger, like so:\n\nhas 'foo' => (\nis      => 'ro',\nisa     => 'Any',\ntrigger => sub {\nmy ( $self, $value ) = @;\nmy $attr = $self->meta->findattributebyname('foo');\n\n# ...\n}\n);\n\n0.66\nIf you created a subtype and passed a parent that Moose didn't know about, it simply ignored the\nparent. Now it automatically creates the parent as a class type. This may not be what you want,\nbut is less broken than before.\n\nYou could declare a name with subtype such as \"Foo!Bar\". Moose would accept this allowed, but if\nyou used it in a parameterized type such as \"ArrayRef[Foo!Bar]\" it wouldn't work. We now do some\nvetting on names created via the sugar functions, so that they can only contain alphanumerics,\n\":\", and \".\".\n\n0.65\nMethods created via an attribute can now fulfill a \"requires\" declaration for a role. Honestly\nwe don't know why Stevan didn't make this work originally, he was just insane or something.\n\nStack traces from inlined code will now report the line and file as being in your class, as\nopposed to in Moose guts.\n\n0.6202\nWhen a class does not provide all of a role's required methods, the error thrown now mentions\nall of the missing methods, as opposed to just the first missing method.\n\nMoose will no longer inline a constructor for your class unless it inherits its constructor from\nMoose::Object, and will warn when it doesn't inline. If you want to force inlining anyway, pass\n\"replaceconstructor => 1\" to \"makeimmutable\".\n\nIf you want to get rid of the warning, pass \"inlineconstructor => 0\".\n\n0.62\nRemoved the (deprecated) \"makeimmutable\" keyword.\n\nRemoving an attribute from a class now also removes delegation (\"handles\") methods installed for\nthat attribute. This is correct behavior, but if you were wrongly relying on it you might get\nbit.\n\n0.58\nRoles now add methods by calling \"addmethod\", not \"aliasmethod\". They make sure to always\nprovide a method object, which will be cloned internally. This means that it is now possible to\ntrack the source of a method provided by a role, and even follow its history through\nintermediate roles. This means that methods added by a role now show up when looking at a\nclass's method list/map.\n\nParameter and Union args are now sorted, this makes Int|Str the same constraint as Str|Int.\nAlso, incoming type constraint strings are normalized to remove all whitespace differences. This\nis mostly for internals and should not affect outside code.\n\nMoose::Exporter will no longer remove a subroutine that the exporting package re-exports. Moose\nre-exports the Carp::confess function, among others. The reasoning is that we cannot know\nwhether you have also explicitly imported those functions for your own use, so we err on the\nsafe side and always keep them.\n\n0.56\n\"Moose::initmeta\" should now be called as a method.\n\nNew modules for extension writers, Moose::Exporter and Moose::Util::MetaRole.\n\n0.5501\nImplemented metaclass traits (and wrote a recipe for it):\n\nuse Moose -traits => 'Foo'\n\nThis should make writing small Moose extensions a little easier.\n\n0.55\nFixed \"coerce\" to accept anon types just like \"subtype\" can. So that you can do:\n\ncoerce $someanontype => from 'Str' => via { ... };\n\n0.51\nAdded \"BUILDARGS\", a new step in \"Moose::Object->new()\".\n\n0.49\nFixed how the \"is => (ro|rw)\" works with custom defined \"reader\", \"writer\" and \"accessor\"\noptions. See the below table for details:\n\nis => ro, writer => foo    # turns into (reader => foo, writer => foo)\nis => rw, writer => foo    # turns into (reader => foo, writer => foo)\nis => rw, accessor => foo  # turns into (accessor => foo)\nis => ro, accessor => foo  # error, accesor is rw\n\n0.45\nThe \"before/around/after\" method modifiers now support regexp matching of method names. NOTE:\nthis only works for classes, it is currently not supported in roles, but, ... patches welcome.\n\nThe \"has\" keyword for roles now accepts the same array ref form that Moose.pm does for classes.\n\nA trigger on a read-only attribute is no longer an error, as it's useful to trigger off of the\nconstructor.\n\nSubtypes of parameterizable types now are parameterizable types themselves.\n\n0.44\nFixed issue where \"DEMOLISHALL\" was eating the value in $@, and so not working correctly. It\nstill kind of eats them, but so does vanilla perl.\n\n0.41\nInherited attributes may now be extended without restriction on the type ('isa', 'does').\n\nThe entire set of Moose::Meta::TypeConstraint::* classes were refactored in this release. If you\nwere relying on their internals you should test your code carefully.\n\n0.40\nDocumenting the use of '+name' with attributes that come from recently composed roles. It makes\nsense, people are using it, and so why not just officially support it.\n\nThe \"Moose::Meta::Class->create\" method now supports roles.\n\nIt is now possible to make anonymous enum types by passing \"enum\" an array reference instead of\nthe \"enum $name => @values\".\n\n0.37\nAdded the \"makeimmutable\" keyword as a shortcut to calling \"makeimmutable\" on the meta object.\nThis eventually got removed!\n\nMade \"initarg => undef\" work in Moose. This means \"do not accept a constructor parameter for\nthis attribute\".\n\nType errors now use the provided message. Prior to this release they didn't.\n\n0.34\nMoose is now a postmodern object system :)\n\nThe Role system was completely refactored. It is 100% backwards compat, but the internals were\ntotally changed. If you relied on the internals then you are advised to test carefully.\n\nAdded method exclusion and aliasing for Roles in this release.\n\nAdded the Moose::Util::TypeConstraints::OptimizedConstraints module.\n\nPassing a list of values to an accessor (which is only expecting one value) used to be silently\nignored, now it throws an error.\n\n0.26\nAdded parameterized types and did a pretty heavy refactoring of the type constraint system.\n\nBetter framework extensibility and better support for \"making your own Moose\".\n\n0.25 or before\nHonestly, you shouldn't be using versions of Moose that are this old, so many bug fixes and\nspeed improvements have been made you would be crazy to not upgrade.\n\nAlso, I am tired of going through the Changelog so I am stopping here, if anyone would like to\ncontinue this please feel free.\n",
                "subsections": []
            },
            "AUTHORS": {
                "content": "*   Stevan Little <stevan@cpan.org>\n\n*   Dave Rolsky <autarch@urth.org>\n\n*   Jesse Luehrs <doy@cpan.org>\n\n*   Shawn M Moore <sartak@cpan.org>\n\n*   יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>\n\n*   Karen Etheridge <ether@cpan.org>\n\n*   Florian Ragwitz <rafl@debian.org>\n\n*   Hans Dieter Pearcey <hdp@cpan.org>\n\n*   Chris Prather <chris@prather.org>\n\n*   Matt S Trout <mstrout@cpan.org>\n",
                "subsections": []
            },
            "COPYRIGHT AND LICENSE": {
                "content": "This software is copyright (c) 2006 by Infinity Interactive, Inc.\n\nThis is free software; you can redistribute it and/or modify it under the same terms as the Perl\n5 programming language system itself.\n",
                "subsections": []
            }
        }
    }
}