TITLE

Metaobject supporting object finalization


SUBTITLE

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


This role takes care that C<DESTROY> submethods are called (if they
exist) when an object is garbage-collected.


head

Collects the C<DESTROY> submethods from this class and all its
superclasses, and marks the class as needing action on garbage
collection.


A metamodel for a kind that implements finalization semantics must call
this method at type composition time.


Returns a list of all finalization methods.


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


Roles, classes, grammars and enums can contain methods. This role implements
the API around storing and introspecting them.


# don't do that, because it changes type Int globally.
# just for demonstration purposes.
Int.^add_method('double', method ($x:) { 2 * $x });
say 21.double; # OUTPUT: «42␤»


Adds a method to the metaclass, to be called with name C<$name>.
This should only be done before a type is composed.


Returns a list of public methods available on the class (which includes
methods from superclasses and roles). By default this stops at the classes
L<C<Cool>|/type/Cool>, L<C<Any>|/type/Any> or L<C<Mu>|/type/Mu>; to really get all methods, use the C<:all> adverb.
If C<:local> is set, only methods declared directly in the class are returned.


say A.^methods();                   # x
say A.^methods(:all);               # x infinite defined ...


The returned list contains objects of type L<C<Method>|/type/Method>, which you can
use to introspect their signatures and call them.


Some introspection method-look-alikes like L<C<WHAT>|/language/mop#WHAT> will
not show up, although they are present in any Raku object. They are handled
at the grammar level and will likely remain so for bootstrap reasons.


Returns a hash where the keys are method names, and the values are
L<C<Method>|/type/Method>s. Note that the keys are the names by which the methods
can be called, not necessarily the names by which the methods know themselves.


Returns the first matching L<C<Method>|/type/Method> object of the provided C<$name>
or C<(Mu)> if no method object was found. The search for a matching method object
is done by following the L<mro|/type/Metamodel::C3MRO> of C<$obj>. Note that
C<lookup> is supposed to be used for introspection, if you're after something
which can be invoked you probably want to use L<find_method|/routine/find_method>
instead.


say 2.5.^lookup("sqrt").raku;      # OUTPUT: «method sqrt (Rat $: *%_) ...␤»
say Str.^lookup("BUILD").raku;     # OUTPUT: «submethod BUILD (Str $: :$value = "", *%_ --> Nil) ...␤»
say Int.^lookup("does-not-exist"); # OUTPUT: «(Mu)␤»


The difference between C<find_method> and C<lookup> are that C<find_method> will
use a default candidate for parametric roles, whereas C<lookup> throws an exception
in this case, and that C<find_method> honors C<FALLBACK> methods, which C<lookup>
does not.


comment

=begin comment

TODO: submethod_table, declares_method, cache, cache_get, cache_add

=end comment


code

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


C<Metamodel::EnumHOW> is the metaclass behind the C<enum> keyword.


enum Numbers <1 2>;
say Numbers.HOW ~~ Metamodel::EnumHOW; # OUTPUT: «True␤»


our Int enum Error <Warning Failure Exception Sorrow Panic>;


Is roughly equivalent to this code using C<Metamodel::EnumHOW>'s methods:


BEGIN {
    my constant Error = Metamodel::EnumHOW.new_type: :name<Error>, :base_type(Int);
    Error.^add_role: Enumeration;
    Error.^add_role: NumericEnumeration;
    Error.^compose;
    for <Warning Failure Exception Sorrow Panic>.kv -> Int $v, Str $k {
        # Note: Enumeration.pred and .succ will not work when adding enum
        # values as pairs. They should be instances of the enum itself, but
        # this isn't possible to do without nqp.
        Error.^add_enum_value: $k => $v;
        OUR::{$k} := Error.^enum_from_value: $v;
    }
    Error.^compose_values;
    OUR::<Error> := Error;
}


method new_type(:$name!, :$base_type?, :$repr = 'P6opaque', :$is_mixin)


Creates a new type object for an enum. C<$name> is the enum name, C<$base_type>
is the type given when the enum is declared using a scoped declaration (if any),
and C<$repr> is the type representation passed to the enum using the C<repr>
trait. C<$is_mixin> is unused.


Sets the base type of an enum. This can only be used if no base type was passed
to C<.new_type>.


method set_export_callback($obj, $callback)


Sets the enum's export callback, which is invoked when calling
C<.compose_values>. This is called when applying the C<export> trait to an
enum. C<$callback> should be a routine of some sort, taking no arguments, that
handles exporting the enum's values.


Returns the export callback set by C<.set_export_callback>.


method compose($obj, :$compiler_services)


Completes a type object for an enum. This is when any roles done by the enum
are mixed in. This needs to be called before any enum values can be added using
C<.add_enum_value>.


Returns 1 if the enum is composed, otherwise returns 0.


Calls the export callback set by C<.set_export_callback> and removes it from
state. This should be called after adding the enum's values using
C<.add_enum_value>.


Sets the composalizer for an enum, which produces a type that can be mixed in
with another. C<$c> should be a routine of some that has the following
signature:


Returns the composalizer set by C<.set_composalizer>.


Adds a value to this enum. C<$value> should be an instance of the enum itself,
as type L<C<Enumeration>|/type/Enumeration>.


enum Numbers <10 20>;
say Numbers.^enum_values;                   # OUTPUT: {10 => 0, 20 => 1}


enum Numbers <10 20>;
say Numbers.^elems;                         # OUTPUT: 2


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


class Metamodel::PackageHOW


Metaobject that supports low-level type operations


class Metamodel::Primitives


Metaobject representing a Raku enum.


class Metamodel::EnumHOW


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

Methods

method setup_finalization

method destroyers

See Also