mro - Method Resolution Order
The "mro" namespace provides several utilities for dealing with method resolution order and method caching in general.
These interfaces are only available in Perl 5.9.5 and higher. See MRO::Compat on CPAN for a mostly forwards compatible implementation for older Perls.
It's possible to change the MRO of a given class either by using
as shown in the synopsis, or by using the mro::set_mro function
below. The functions in the mro namespace do not require loading the
module, as they are actually provided by the core perl interpreter.
In addition to the traditional Perl default MRO (depth first
here), Perl now offers the C3 MRO as
well. Perl's support for C3 is based on the work done in
Stevan Little's module Class::C3, and most of the C3-related
documentation here is ripped directly from there.
C3 is the name of an algorithm which aims to provide a sane method resolution order under multiple inheritance. It was first introduced in the language Dylan (see links in the SEE ALSO section), and then later adopted as the preferred MRO (Method Resolution Order) for the new-style classes in Python 2.3. Most recently it has been adopted as the "canonical" MRO for Perl 6 classes, and the default MRO for Parrot objects as well.
C3 works by always preserving local precendence ordering. This essentially means that no class will appear before any of its subclasses. Take, for instance, the classic diamond inheritance pattern:
- / \
- <B> <C>
- \ /
The standard Perl 5 MRO would be (D, B, A, C). The result being that A appears before C, even though C is the subclass of A. The C3 MRO algorithm however, produces the following order: (D, B, C, A), which does not have this issue.
This example is fairly trivial; for more complex cases and a deeper explanation, see the links in the SEE ALSO section.
Returns an arrayref which is the linearized MRO of the given class.
Uses whichever MRO is currently in effect for that class by default,
or the given MRO (either
if specified as
The linearized MRO of a class is an ordered array of all of the classes one would search when resolving a method on that class, starting with the class itself.
If the requested class doesn't yet exist, this function will still
succeed, and return
[ $classname ]
(and any members of
's MRO) are not
part of the MRO of a class, even though all classes implicitly inherit
and its parents.
Sets the MRO of the given class to the
Returns the MRO of the given class (either
for this class, returned as an
arrayref of class names. These are every class that "isa"
the given class name, even if the isa relationship is
indirect. This is used internally by the MRO code to
keep track of method/MRO cache invalidations.
Currently, this list only grows, it never shrinks. This
was a performance consideration (properly tracking and
deleting isarev entries when someone removes an entry
is costly, and it doesn't happen often
anyways). The fact that a class which no longer truly
"isa" this class at runtime remains on the list should be
considered a quirky implementation detail which is subject
to future change. It shouldn't be an issue as long as
you're looking at this list for the same reasons the
core code does: as a performance optimization
over having to search every class in existence.
(and parents') isarev lists do not include
every class in existence, even though all classes are
effectively descendants for method inheritance purposes.
Returns a boolean status indicating whether or not
the given classname is either
or one of
's parents by
Any class for which this function returns true is "universal" in the sense that all classes potentially inherit methods from it.
For similar reasons to
above, this flag is
permanent. Once it is set, it does not go away, even
if the class in question really isn't universal anymore.
, which invalidates method
caching in all packages.
Invalidates the method cache of any classes dependent on the given class. This is not normally necessary. The only known case where pure perl code can confuse the method cache is when you manually install a new constant subroutine by using a readonly scalar value, like the internals of constant do. If you find another case, please report it so we can either fix it or document the exception here.
Returns an integer which is incremented every time a
real local method in the package
or the local
This is intended for authors of modules which do lots
of class introspection, as it allows them to very quickly
check if anything important about the local properties
of a given class have changed since the last time they
looked. It does not increment on method/
changes in superclasses.
It's still up to you to seek out the actual changes, and there might not actually be any. Perhaps all of the changes since you last checked cancelled each other out and left the package in the state it was in before.
This integer normally starts off at a value of
when a package stash is instantiated. Calling it
on packages whose stashes do not exist at all will
. If a package stash is completely
deleted (not a normal occurence, but it can happen
if someone does something like
the number will be reset to either
depending on how completely package was wiped out.
This is somewhat like
, but it uses the C3 method
resolution order to get better consistency in multiple
inheritance situations. Note that while inheritance in
general follows whichever MRO is in effect for the
next::method only uses the C3 MRO.
One generally uses it like so:
Note that you don't (re-)specify the method name. It forces you to always use the same method name as the method you started in.
It can be called on an object or a class, of course.
The way it resolves which actual method to call is:
First, it determines the linearized C3 MRO of the object or class it is being called on.
Then, it determines the class and method name of the context it was invoked from.
Finally, it searches down the C3 MRO list until it reaches the contextually enclosing class, then searches further down the MRO list for the next method with the same name as the contextually enclosing method.
Failure to find a next method will result in an exception being thrown (see below for alternatives).
This is substantially different than the behavior
under complex multiple inheritance.
(This becomes obvious when one realizes that the
common superclasses in the C3 linearizations of
a given class and one of its parents will not
always be ordered the same for both.)
next::method from methods defined outside the class:
There is an edge case when using
next::method from within a subroutine
which was created in a different module than the one it is called from. It
sounds complicated, but it really isn't. Here is an example which will not
The problem exists because the anonymous subroutine being assigned to the
glob will show up in the call stack as being called
as you might expect. Since
caller to find the name of the method it was called in, it will fail in
But fear not, there's a simple solution. The module
reach into the perl internals and assign a name to an anonymous subroutine
for you. Simply do this:
and things will Just Work.
In simple cases, it is equivalent to:
- $self->next::method(@_) if $self->next_can;
But there are some cases where only this solution
Brandon L. Black, <firstname.lastname@example.org>
Based on Stevan Little's Class::C3