TITLE

Represents a non-instantiated, parameterized, role.


SUBTITLE

code

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


A C<Metamodel::ParametricRoleHOW> represents a non-instantiated, possibly
parameterized, role:


As usual, C<.new_type> will create a new object of this class.


The extra C<group> argument will need to be used to integrate it in a parametric
role group, which will need to be defined in advance.


I<Note>: As most of the C<Metamodel> classes, this one is here mainly for
illustration purposes and it's not intended for the final user to instantiate,
unless their intention is really to create a parametric role group.


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


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


Metaobject that supports low-level type operations


C<Metamodel::Primitives> provides low-level operations for working with types,
which are otherwise only available as implementation-dependent directives. These
primitives are available as class methods.


Here is an example that steals the metamodel instance from the
L<C<Int>|/type/Int> class to create a custom type (usually you would create your
own metaclass if you mess with something as low-level), which allows calling
of just one method called C<why>:


my Mu $type := Metamodel::Primitives.create_type(Int.HOW, 'P6opaque');
$type.^set_name('why oh why?');
my %methods =  why => sub ($) { say 42 };
Metamodel::Primitives.install_method_cache($type, %methods, :authoritative);
$type.why;      # 42
$type.list;
CATCH { default { put .^name, ': ', .Str } };
# OUTPUT: «X::Method::NotFound: Method 'list' not found for invocant of class 'why oh why?'␤»


Every metaobject has the capacity to hold a parameterization cache. This is
distinct from the C<parameterize> metamethod backing parameterization syntax.
For example, a package can be parametric in this low-level sense:


package Cache {
    our sub parameterize(+args) is raw {
        Metamodel::Primitives.parameterize_type: $?PACKAGE, args
    }


sub noop(Mu, Mu \args) is raw {
    args
}


BEGIN Metamodel::Primitives.set_parameterizer: $?PACKAGE, &noop;
}


head

method create_type(Mu $how, $repr = 'P6opaque')


Creates and returns a new type from a metaobject C<$how> and a representation
name.


Sets the package associated with the type.


method install_method_cache( Mu $type, %cache, :$authoritative = True)


Installs a method cache, that is, a mapping from method names to code objects.
If C<:authoritative> is missing, or set to C<True>, then calls of methods that
do not exist in the cache will throw an exception of type
L<C<X::Method::NotFound>|/type/X::Method::NotFound>. If C<:authoritative> is set
to C<False>, the usual fallback mechanism are tried.


method configure_type_checking( Mu $type, @cache, :$authoritative = True, :$call_accepts = False )


Configures the type checking for C<$type>. C<@cache> is a list of known types
against which C<$type> checks positively (so in a classical class-based system,
the type itself and all recursive superclasses). If C<:authoritative> is missing
or C<True>, this type will fail checks against all types not in C<@cache>. If
C<:call_accepts> is True, the method L<ACCEPTS|/routine/ACCEPTS> will be called
for type checks against this type.


method configure_destroy(Mu $type, $destroy)


Configures whether C<DESTROY> methods are called (if present) when the garbage
collector collects an object of this type (if C<$destroy> is set to a true
value). This comes with a performance overhead, so should only be set to a
true value if necessary.


method compose_type(Mu $type, $configuration)


Composes C<$type> (that is, finalizes it to be ready for instantiation). See
L<https://github.com/Raku/nqp/blob/master/docs/6model/repr-compose-protocol.markdown>
for what C<$configuration> can contain (until we have better docs, sorry).


Changes C<$object> to be of type C<$type>. This only works if C<$type>
type-checks against the current type of C<$object>, and if the storage of
C<$object> is a subset of that of C<$type>. N<As of Raku 2019.11, this method
 requires
L<special arrangements|https://github.com/rakudo/rakudo/issues/3414#issuecomment-573251877>.>


method is_type(Mu \obj, Mu \type --> Bool:D)


method set_parameterizer(Mu \obj, &parameterizer --> Nil)


Initializes the parameterization cache for a metaobject. This incorporates the
C<&parameterize> routine to produce parameterizations to be cached. This is
assumed to carry a signature compatible with C<:(Mu $root, List:D $args)>,
C<$root> being the base metaobject for the parameterization, C<$args> being the
type arguments' object buffer.


method parameterize_type(Mu \obj, +parameters --> Mu)


Parameterizes a metaobject prepared by C<set_parameterizer> with C<parameters>.
The resulting metaobject is cached by literal object comparisons with C<=:=>
for each element of C<parameters>. I<Containers tend to invalidate any match>.


method type_parameterized(Mu \obj --> Mu)


Returns the base metaobject from a parameterization given its resulting C<obj>.
Returns L<C<Mu>|/type/Mu> if none was ever performed.


method type_parameters(Mu \obj --> List:D)


Returns the type arguments' object buffer from a parameterization given its
resulting C<obj>. Dies if none was ever performed.


method type_parameter_at(Mu \obj, Int:D \idx --> Mu) is raw


Returns a particular object from a parameterization given its resulting C<obj>
and an index, skipping the L<C<List>|/type/List>-building step of C<type_parameters>. Dies if
none was ever performed.


Metaobject representing a Raku class.


class Metamodel::ClassHOW


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


class Metamodel::Primitives


class Metamodel::ParametricRoleGroupHOW
    does Metamodel::Naming
    does Metamodel::Documenting
    does Metamodel::Stashing
    does Metamodel::TypePretense
    does Metamodel::RolePunning
    does Metamodel::BoolificationProtocol {}


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


A C<ParametricRoleGroupHOW> groups a set of C<ParametricRoleHOW>, every one of them representing a single role declaration with their own parameter sets.


C<ParametricRoleHOW>s need to be added to this kind of group:


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.


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