TITLE

Metaobject that supports resolving inherited methods


SUBTITLE

role Metamodel::MROBasedMethodDispatch { }


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


This role implements locating methods based on the method resolution order of
related (usually "super"/"parent") types.


head

method find_method($obj, $name, :$no_fallback, *%adverbs)


Given a method name, it returns the method object of that name which is closest
in the method resolution order (MRO). If no method can be found, it 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>:


code

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


If C<:no_fallback> is supplied, fallback methods are not considered.


method find_method_qualified($obj, $type, $name)


Given a method name and a type, returns the method from that type. This is
used in calls like


Returns the list of methods of that name the object can do.


Walk MRO and add methods to cache, unless another method lower in the class
hierarchy "shadowed" it.


root

Metaobject that can hold attributes


role Metamodel::AttributeContainer


Metaobject that supports the C3 method resolution order


role Metamodel::C3MRO


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 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::MROBasedMethodDispatch


Classes, roles and grammars can have parent classes, that is, classes to which
method lookups fall back to, and to whose type the child class conforms to.


This role implements the capability of having zero, one or more parent (or
I<super>) classes.


In addition, it supports the notion of I<hidden> classes, whose methods are
excluded from the normal dispatching chain, so that for example C<nextsame>
ignores it.


This can come in two flavors: methods from a class marked as C<is hidden>
are generally excluded from dispatching chains, and C<class A hides B> adds
C<B> as a parent class to C<A>, but hides it from the method resolution order,
so that L<mro_unhidden|/type/Metamodel::C3MRO#method_mro_unhidden> skips it.


method add_parent($obj, $parent, :$hides)


Adds C<$parent> as a parent type. If C<$hides> is set to a true value, the
parent type is added as a hidden parent.


C<$parent> must be a fully
L<composed|/language/mop#Composition_time_and_static_reasoning> typed.
Otherwise an exception of type L<C<X::Inheritance::NotComposed>|/type/X::Inheritance::NotComposed>
is thrown.


Returns the list of parent classes. By default it stops at L<C<Cool>|/type/Cool>, L<C<Any>|/type/Any> or
L<C<Mu>|/type/Mu>, which you can suppress by supplying the C<:all> adverb. With C<:tree>,
a nested list is returned.


class D { };
class C1 is D { };
class C2 is D { };
class B is C1 is C2 { };
class A is B { };


say A.^parents(:all).raku;
# OUTPUT: «(B, C1, C2, D, Any, Mu)␤»
say A.^parents(:all, :tree).raku;
# OUTPUT: «[B, ([C1, [D, [Any, [Mu]]]], [C2, [D, [Any, [Mu]]]])]␤»


Returns a list of all hidden parent classes.


Returns a true value if (and only if) the class is marked with the trait C<is
hidden>.


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


Using the C<does> and C<but> infix operators, I<mixins> of a base object
and an arbitrary number of roles (or another object) can be created.
These are objects whose types have properties of both operands' types.
Respectively, these rebless the existing object to have the generated
mixin type and clone said object with said mixin type:


=begin code
class Billboard {
    has Str:D $.advertisement is required;

    method vandalism(::?CLASS:D: --> Str:D) { ... }

    multi method Str(::?CLASS:D: --> Str:D) { $!advertisement }

    role Vandalized[Str:D :$vandalism] {
        method vandalism(::?CLASS:D: --> Str:D) { $vandalism }

        multi method Str(::?CLASS:D: --> Str:D) { $vandalism }
    }
}

my Str:D $advertisement = Q:to/ADVERTISEMENT/.chomp;
Brilliant Solutions: sane and knowledgeable consultants.
We have been providing excellent services since 1972!
ADVERTISEMENT
my Str:D $vandalism = Q:to/VANDALISM/.chomp;
          S       s  s ne     k          l   o   l     .
We    e  ee            e  e  e    e    e      e     !
VANDALISM

my Billboard:D $billboard .= new: :$advertisement;
say $billboard eq $advertisement; # OUTPUT: «True␤»

my Billboard:D $draft = $billboard but Billboard::Vandalized[:$vandalism];
say $draft eq $vandalism; # OUTPUT: «True␤»

$billboard does Billboard::Vandalized[:$vandalism];
say $billboard eq $vandalism; # OUTPUT: «True␤»
=end code


Optionally, mixins may have a I<mixin attribute>. This occurs when only
one role having only one public attribute gets mixed into an object.  If
a mixin attribute exists on a resulting mixin's type, it can be
initialized by C<but> or C<does> using its C<value> named parameter.
This makes it possible for mixins to not only have composable methods,
but composable state as well. Using this feature, the example above can
be rewritten so billboards can be vandalized more than once without
needing to generate more mixins by making C<Billboard::Vandalism>'s
C<$vandalism> named parameter a L<rw|/type/Attribute#trait_is_rw>
mixin attribute instead:


=begin code
class Billboard {
    has Str:D $.advertisement is required;

    method vandalism(::?CLASS:D: --> Str:D) { ... }

    multi method Str(::?CLASS:D: --> Str:D) { $!advertisement }

    role Vandalized {
        has Str:D $.vandalism is required is rw;

        multi method Str(::?CLASS:D: --> Str:D) { $!vandalism }
    }
}

my Str:D $advertisement = Q:to/ADVERTISEMENT/.chomp;
Brilliant Solutions: sane and knowledgeable consultants.
We have been providing excellent services since 1972!
ADVERTISEMENT
my Str:D $vandalism = Q:to/VANDALISM/.chomp;
          S       s  s ne     k          l   o   l     .
We    e  ee            e  e  e    e    e      e     !
VANDALISM
my Str:D $false-alarm = Qs:to/FALSE-ALARM/.chomp;
$vandalism
⬆️ This is just one of our namesakes we at Brilliant Solutions have been
helping people like you create since 1972!
FALSE-ALARM

my Billboard:D $billboard .= new: :$advertisement;
say $billboard eq $advertisement; # OUTPUT: «True␤»

$billboard does Billboard::Vandalized :value($vandalism);
say $billboard eq $vandalism; # OUTPUT: «True␤»

$billboard.vandalism = $false-alarm;
say $billboard eq $false-alarm; # OUTPUT: «True␤»
=end code


C<Metamodel::Mixins> is the metarole that implements the behavior of
said mixins. Formally, mixins are objects whose HOW inherits from a base
composable metaobject and applies an arbitrary number of roles,
resulting in an object whose HOW has a combination of their properties.
In particular, the metamethods this metarole provides are used to
implement the behavior of the C<but> and C<does> infix operators, but
these also support introspection related to mixins. For example, the
work done by C<but> when invoked with an object and one role can be
written explicitly using the C<mixin> metamethod provided:


=begin code
class Foo { }
role Bar { }

say Foo.new but Bar;     # OUTPUT: «Foo+{Bar}.new␤»
say Foo.new.^mixin(Bar); # OUTPUT: «Foo+{Bar}.new␤»
=end code


comment

Returns C<1> If C<$obj> has been marked as being a mixin with
C<set_is_mixin>, otherwise returns C<0>.


Sets the mixin attribute for C<$obj> to C<$attr> (which should be an
L<C<Attribute>|/type/Attribute> instance).


Returns the mixin attribute for C<$obj> set with
C<set_mixin_attribute>.


Sets up caching of mixins for C<$obj>. After this metamethod has been
called, calls to C<mixin> will not create a new type for mixins of
C<$obj> given the same list of roles more than once. This should be
called at some point before composition.


Creates a new mixin metaobject that inherits from C<$obj> and does each
of the roles in C<@roles>. This is then composed and has its mixin
attribute set (if any exists) before getting returned.


While this generates a new mixin type, this doesn't actually mix it into
C<$obj>; if that is what you intend to do, use the L<mixin|/routine/mixin> metamethod
instead.


method mixin($obj, *@roles, :$needs-mixin-attribute)


Generates a new mixin type by calling C<generate_mixin> with C<$obj> and
C<@roles>. If C<$obj> is composed, the mixin cache of C<$obj> will be checked
for any existing mixin for these beforehand. If C<$obj> is an instance of a
type, this will return C<$obj> reblessed with the mixin generated, otherwise
this will return the mixin itself.


If C<$needs-mixin-attribute> is C<True>, this will throw an exception if
no mixin attribute exists on the mixin generated before returning.


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::MROBasedMethodDispatch

Methods

method find_method

method find_method_qualified

method can

method publish_method_cache

See Also