类 Metamodel::ClassHOW

表示 Raku 类的元对象。

    class Metamodel::ClassHOW
        does Metamodel::Naming
        does Metamodel::Documenting
        does Metamodel::Versioning
        does Metamodel::Stashing
        does Metamodel::AttributeContainer
        does Metamodel::MethodContainer
        does Metamodel::PrivateMethodContainer
        does Metamodel::MultiMethodContainer
        does Metamodel::RoleContainer
        does Metamodel::MultipleInheritance
        does Metamodel::DefaultParent
        does Metamodel::C3MRO
        does Metamodel::MROBasedMethodDispatch
        does Metamodel::MROBasedTypeChecking
        does Metamodel::Trusting
        does Metamodel::BUILDPLAN
        does Metamodel::Mixins
        does Metamodel::ArrayType
        does Metamodel::BoolificationProtocol
        does Metamodel::REPRComposeProtocol
        does Metamodel::Finalization
            { }

警告：此类是 Rakudo 实现的一部分，不属于语言规范。

Metamodel::ClassHOW 是 class 关键字背后的元类。

say so Int.HOW ~~ Metamodel::ClassHOW;    # OUTPUT: «True␤» 
say Int.^methods(:all).pick.name;         # OUTPUT: «random Int method name␤»

方法§

方法 add_fallback§

method add_fallback($obj, $condition, $calculator)

安装方法后备，即添加一种调用未静态添加的方法的方法。

$condition 和 $calculator 都必须是可调用对象，一旦调用了方法缓存中找不到的方法，它们就会接收调用者和方法名称。

如果 $condition 返回真值，则使用相同的参数调用 $calculator，并且必须返回要作为方法调用的代码对象，并将其添加到方法缓存中。

如果 $condition 返回假值，则尝试下一个后备（如果有），如果都不匹配，则抛出 类型为 X::Method::NotFound 的异常。

面向用户的代码（即不涉及元类的代码）应该使用 FALLBACK 方法。

方法 can§

method can($obj, $method-name)

给定一个方法名称，它返回一个 List，其中列出了可以使用此名称的方法。

class A      { method x($a) {} };
class B is A { method x()   {} };
say B.^can('x').elems;              # OUTPUT: «2␤» 
for B.^can('x') {
    say .arity;                     # OUTPUT: «1, 2␤» 
}

在此示例中，类 B 有两个可以使用名称 x 的可能方法（尽管普通方法调用只会调用直接安装在 B 中的方法）。B 中的方法具有元数 1（即它期望一个参数，即调用者（self）），而 A 中的方法期望 2 个参数（self 和 $a）。

方法 lookup§

method lookup($obj, $method-name --> Method:D)

返回第一个匹配的 Method，其名称已提供。如果未找到方法，则返回特定于 VM 的哨兵值（通常是低级 NULL 值），可以使用 定义性 测试对此值进行测试。它可能比 .^can 更快，但不会提供所有候选者的完整列表。

    say Str.^lookup('Int').raku; # OUTPUT: «method Int (Str:D $: *%_) { #`(Method|39910024) ... }␤» 
 
    for <upper-case  uc> {
        Str.^lookup: $^meth andthen .("foo").say
            orelse "method `$meth` not found".say
    }
    # OUTPUT: 
    # method `upper-case` not found 
    # FOO 

方法 compose§

method compose($obj)

调用 compose 会使元对象及其表示的类进入完全功能状态，因此，如果你构造或修改了一个类，则必须在使用该类之前调用 compose 方法。

它会更新方法缓存，检查角色所需的所有方法是否已实现，执行实际的角色组合工作，并设置类以与语言互操作性配合良好。

方法 new_type§

method (:$name, :$repr = 'P6opaque', :$ver, :$auth)

从元模型创建新类型，我们可以继续构建

my $type = Metamodel::ClassHOW.new_type(name => "NewType",
                                        ver => v0.0.1,
                                        auth => 'github:raku' );
$type.HOW.add_method($type,"hey", method { say "Hey" });
$type.hey;     # OUTPUT: «Hey␤» 
$type.HOW.compose($type);
my $instance = $type.new;
$instance.hey; # OUTPUT: «Hey␤»

我们通过使用高阶工作方法添加单个方法，然后我们可以直接将该方法用作类方法；然后我们可以组合类型，之后我们可以创建一个实例，该实例的行为方式完全相同。