TITLE

Metaobject that supports the C3 method resolution order


SUBTITLE

I<Warning>: this role is part of the Rakudo implementation, and is not
a part of the language specification.


L<Metamodel|/language/mop> role for the
L<I<C3> method resolution order (MRO)|https://en.wikipedia.org/wiki/C3_linearization>.
I<Note>: this method,
along with almost the whole metamodel, is part of the Rakudo implementation.


The I<method resolution order> for a type is a flat list of types including the
type itself, and (recursively) all super classes. It determines in which order
the types will be visited for determining which method to call with a given
name, or for finding the next method in a chain with
L<nextsame|/language/functions#sub_nextsame>,
L<callsame|/language/functions#sub_callsame>,
L<nextwith|/language/functions#sub_nextwith> or
L<callwith|/language/functions#sub_callwith>.


code

=begin code
class CommonAncestor { };   # implicitly inherits from Any
class Child1 is CommonAncestor { }
class Child2 is CommonAncestor { }
class GrandChild2 is Child2 { }
class Weird is Child1 is GrandChild2 { };

say Weird.^mro; # OUTPUT: «(Weird) (Child1) (GrandChild2) (Child2) (CommonAncestor) (Any) (Mu)␤»
=end code


C3 is the default resolution order for classes and grammars in Raku.
Note that roles generally do not appear in the method resolution order (unless
they are punned into a class, from which another type inherits), because
methods are copied into classes at role application time.


head

Returns a list of types in the method resolution order, even those that are
marked C<is hidden>.


say Int.^mro;   # OUTPUT: «((Int) (Cool) (Any) (Mu))␤»


Returns a list of types in method resolution order, excluding those that are
marked with C<is hidden>.


root

Metaobject that can hold attributes


role Metamodel::AttributeContainer


Metarole for documenting types.


role Metamodel::Documenting


Metaobject supporting object finalization


role Metamodel::Finalization


Metaobject that supports storing and introspecting methods


role Metamodel::MethodContainer


Metaobject for generating mixins


role Metamodel::Mixins


Metaobject that supports resolving inherited methods


role Metamodel::MROBasedMethodDispatch


Metaobject that supports multiple inheritance


role Metamodel::MultipleInheritance


Metaobject that supports named types


role Metamodel::Naming


Represents a group of roles with different parameterizations


role Metamodel::ParametricRoleGroupHOW


Represents a non-instantiated, parameterized, role.


role Metamodel::ParametricRoleHOW


Metaobject that supports private methods


role Metamodel::PrivateMethodContainer


Metaobject that supports holding/containing roles


role Metamodel::RoleContainer


Metaobject that supports punning of roles.


role Metamodel::RolePunning


Metarole for type stashes


role Metamodel::Stashing


Metaobject that supports trust relations between types


role Metamodel::Trusting


Metaobjects that support versioning


role Metamodel::Versioning


para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

role Metamodel::C3MRO


I<Warning>: this class is part of the Rakudo implementation, and is not
a part of the language specification.


C<Metamodel::ClassHOW> is the metaclass behind the C<class> keyword.


say so Int.HOW ~~ Metamodel::ClassHOW;    # OUTPUT: «True␤»
say Int.^methods(:all).pick.name;         # OUTPUT: «random Int method name␤»


method add_fallback($obj, $condition, $calculator)


Installs a method fallback, that is, add a way to call methods that weren't
statically added.


Both C<$condition> and C<$calculator> must be callables that receive the
invocant and the method name once a method is called that can't be found in
the method cache.


If C<$condition> returns a true value,
C<$calculator> is called with the same arguments, and must return the code
object to be invoked as the method, and is added to the method cache.


If C<$condition> returns a false value, the
next fallback (if any) is tried, and if none matches, an exception
L<of type X::Method::NotFound|/type/X::Method::NotFound> is thrown.


User-facing code (that is, code not dabbling with metaclasses) should use
method C<FALLBACK> instead.


Given a method name, it returns a L<C<List>|/type/List> of methods that are
available with this name.


class A      { method x($a) {} };
class B is A { method x()   {} };
say B.^can('x').elems;              # OUTPUT: «2␤»
for B.^can('x') {
    say .arity;                     # OUTPUT: «1, 2␤»
}


In this example, class C<B> has two possible methods available with name C<x>
(though a normal method call would only invoke the one installed in C<B>
directly). The one in C<B> has arity 1 (i.e. it expects one argument, the
invocant (C<self>)), and the one in C<A> expects 2 arguments (C<self> and
C<$a>).


method lookup($obj, $method-name --> Method:D)


Returns the first matching L<C<Method>|/type/Method> with the provided name. If no
method was found, returns a VM-specific sentinel value (typically a low-level
NULL value) that can be tested for with a test for
L<definedness|/routine/defined>. It is potentially faster than C<.^can> but does
not provide a full list of all candidates.


=begin code
    say Str.^lookup('Int').raku; # OUTPUT: «method Int (Str:D $: *%_) { #`(Method|39910024) ... }␤»

    for <upper-case  uc> {
        Str.^lookup: $^meth andthen .("foo").say
            orelse "method `$meth` not found".say
    }
    # OUTPUT:
    # method `upper-case` not found
    # FOO
=end code


A call to C<compose> brings the metaobject and thus the class it represents
into a fully functional state, so if you construct or modify a class, you must
call the compose method before working with the class.


It updates the method cache, checks that all methods that are required by
roles are implemented, does the actual role composition work, and sets up
the class to work well with language interoperability.


method (:$name, :$repr = 'P6opaque', :$ver, :$auth)


Creates a new type from the metamodel, which we can proceed to build


my $type = Metamodel::ClassHOW.new_type(name => "NewType",
                                        ver => v0.0.1,
                                        auth => 'github:raku' );
$type.HOW.add_method($type,"hey", method { say "Hey" });
$type.hey;     # OUTPUT: «Hey␤»
$type.HOW.compose($type);
my $instance = $type.new;
$instance.hey; # OUTPUT: «Hey␤»


We add a single method by using
L<Higher Order Workings|/language/mop#HOW> methods, and
then we can use
that method directly as class method; we can then C<compose> the type, following
which we can create already an instance, which will behave in the exact same
way.


Provides an implementation of a concrete instance of a role


role Metamodel::ConcreteRoleHOW


Support for parameterized roles that have not been instantiated


role Metamodel::CurriedRoleHOW


Metaobject for type definiteness


class Metamodel::DefiniteHOW


Metaobject representing a Raku enum.


class Metamodel::EnumHOW


Metaobject representing a Raku package.


class Metamodel::PackageHOW


Metaobject that supports low-level type operations


class Metamodel::Primitives


Metaobject representing a Raku class.


class Metamodel::ClassHOW


Classes, roles and grammars can have attributes. Storage and introspection of
attributes is implemented by this role.


Adds an attribute. C<$attribute> must be an object that supports the
methods C<name>,  C<type> and C<package>, which are called without arguments.
It can for example be of L<type Attribute|/type/Attribute>.


Returns a list of attributes. For most Raku types, these will be objects of
L<type Attribute|/type/Attribute>.


Marks a type whose attributes default to having a write accessor. For example
in


class Point is rw {
    has $.x;
    has $.y;
}


The C<is rw> trait on the class calls the C<set_rw> method on the metaclass,
making all the attributes implicitly writable, so that you can write;


=begin code :preamble<class Point {}>
my $p = Point.new(x => 1, y => 2);
$p.x = 42;
=end code


Returns a true value if L<method set_rw|#method set_rw> has been called on
this object, that is, if new public attributes are writable by default.


comment

=begin comment

TODO: compose_attributes, get_attribute_for_usage

Also TODO: describe :local, :excl, :all options of method attributes

=end comment


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


role Metamodel::C3MRO

Methods

method compute_mro

method mro

method mro_unhidden

See Also