TITLE

Provides an implementation of a concrete instance of a role


SUBTITLE

code

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


You can use this to build roles, in the same way that C<ClassHOW> can be used to
build classes:


The main difference with
L<C<ClassHOW.new_type>|/type/Metamodel::ClassHOW#method_new_type> is that you
can mix-in roles in this newly created one.


This class is Rakudo specific, and provided only for completeness. Not really
intended to be used by the final user.


root

Metaobject representing a Raku class.


class Metamodel::ClassHOW


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


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


Sometimes, we see references to roles that provide parameters but
do not fully resolve them. For example, in:


We need to represent C<R[T]>, but we cannot yet fully specialize the
role because we don't have the first parameter at hand. We may also
run into the issue where we have things like:


Where we clearly want to talk about a partial parameterization of a
role and actually want to do so in a way distinct from a particular
instantiation of it. This metaobject represents those "partial types"
as both a way to curry on your way to a full specialization, but also
as a way to do type-checking or punning.


This class will show up in parameterized roles. For instance:


=begin code
role Zipi[::T] {
    method zape { "Uses " ~ T.^name };
}
role Zipi[::T, ::Y] {
    method zape { "Uses " ~ T.^name ~ " and " ~ Y.^name };
}
for Zipi[Int], Zipi[Int,Str] -> $role {
    say $role.HOW;
    say $role.new().zape;
}
# OUTPUT:
# Perl6::Metamodel::CurriedRoleHOW.new
# Uses Int
# Perl6::Metamodel::CurriedRoleHOW.new
# Uses Int and Str
=end code


Since there are several variants of C<Zipi>, providing a parameter I<curries>
it, but it's still up to the compiler to find out the actual realization taking
into account the C<ParametricRoleGroup>, so these (partially instantiated) roles
show up as C<Metamodel::CurriedRoleHOW> as shown in the example; even if there's
a single parameter an instantiated role will also be of the same type:


role Zape[::T] {};
say Zape[Int].HOW; #: «Perl6::Metamodel::CurriedRoleHOW.new␤»


I<Note>: As most of the C<Metamodel> classes, this class is here mainly for
illustration purposes and it's not intended for the final user to instantiate.


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␤»


head

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.


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


See Also