class Metamodel::CurriedRoleHOW
        does Metamodel::Naming
        does Metamodel::TypePretense
        does Metamodel::RolePunning {}

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

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

class C does R[Type{ }

We need to represent 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:

sub foo(R[T$x{ ... }
if $x ~~ R[T{ ... }

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:

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 $;
# Uses Int 
# Uses Int and Str 

Since there are several variants of Zipi, providing a parameter curries it, but it's still up to the compiler to find out the actual realization taking into account the ParametricRoleGroup, so these (partially instantiated) roles show up as 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#: «␤»

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