Rules / Types, classes & roles / metamodel

Metamodel::Primitives Reference

Metaobject that supports low-level type operations

What it is #

Routines #

Signatures are reproduced from the documentation, including their declared return types. A routine listed here is part of the type's published interface; whether Raku++ implements it is a separate question, answered by the examples below.

method create_type #

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

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

method set_package #

method set_package(Mu $type, $package)

Sets the package associated with the type.

method install_method_cache #

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

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

method configure_type_checking #

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

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

method configure_destroy #

method configure_destroy(Mu $type, $destroy)

Configures whether DESTROY methods are called (if present) when the garbage collector collects an object of this type (if $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 #

method compose_type(Mu $type, $configuration)

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

method rebless #

method rebless(Mu $object, Mu $type)

Changes $object to be of type $type. This only works if $type type-checks against the current type of $object, and if the storage of $object is a subset of that of $type. N<As of Raku 2019.11, this method requires special arrangements.>

method is_type #

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

Returns Bool:D.

Type-checks obj against type

method set_parameterizer #

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

Returns Nil.

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

method parameterize_type #

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

Returns Mu.

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

method type_parameterized #

method type_parameterized(Mu \obj --> Mu)

Returns Mu.

Returns the base metaobject from a parameterization given its resulting obj. Returns Mu if none was ever performed.

method type_parameters #

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

Returns List:D.

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

method type_parameter_at #

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

Returns Mu.

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

Examples, run three ways #

Every example below comes from the official documentation, together with the output that documentation asserts. Each was then executed by Rakudo and by Raku++ when this page was built. Where the three agree, one result is shown; where they do not, all three are — because which of them is wrong is exactly the information worth having.

1 all-differ · 4 no-output

class Metamodel::Primitives {}

Not executed: the documentation states no expected output for this example.

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?'␤»
Documentation
X::Method::NotFound: Method 'list' not found for invocant of class 'why oh why?'
Rakudo
X::Method::NotFound: No such method 'why' for invocant of type 'why oh why?'. Did you mean
'WHO'?
Raku++
X::Method::NotFound: No such method 'create_type' for invocant of type 'Metamodel::Primitives'

All three differ. Needs a human.

Not yet examined. Which of these is correct has not been established — do not treat either engine as settled here.

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

Not executed: the documentation states no expected output for this example.

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

Not executed: the documentation states no expected output for this example.

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

Not executed: the documentation states no expected output for this example.