TITLE

Metaobject that supports private methods


SUBTITLE

role Metamodel::PrivateMethodContainer { ... }


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


In Raku, classes, roles and grammars can have private methods, that is,
methods that are only callable from within it, and are not inherited by
types derived by inheritance.


class A {
    # the ! declares a private method
    method !double($x) {
        say 2 * $x;
    }
    method call-double($y) {
        # call with ! instead of .
        self!double($y);
    }
}


For the purposes of dispatching and scoping, private methods are closer
to subroutines than to methods. However they share access to C<self> and
attributes with methods.


head

code

Adds a private method C<$code> with name C<$name>.


Returns a hash of C«name => &method_object»


Locates a private method. Otherwise, returns L<C<Mu>|/type/Mu> if it doesn't
exist.


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


Represents a non-instantiated, parameterized, role.


role Metamodel::ParametricRoleHOW


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


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


Implements the ability to hold roles to be held for composition.


Adds the C<$role> to the list of roles to be composed.


method roles_to_compose($obj --> List:D)


returns a list of roles added with C<add_role>, which are to be composed
at type composition time.


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


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


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

Methods

method add_private_method

method private_method_table

method private_methods

method private_method_names

method find_private_method

See Also