类 Mu

Raku 类型层次结构的根。

class Mu { }

Raku 类型层次结构的根。关于名称的起源，请参阅维基百科上的 Mu (negative)。也可以说 Raku 中有很多未定义的值，而 Mu 是最未定义的值。

请注意，大多数类不直接派生自 Mu，而是派生自 Any。

方法§

方法迭代器§

method iterator(--> Iterator)

通过应用其 .list 方法将调用者强制转换为 list，并对其使用 iterator。

my $it = Mu.iterator;
say $it.pull-one; # OUTPUT: «(Mu)␤» 
say $it.pull-one; # OUTPUT: «IterationEnd␤»

方法定义§

multi method defined(   --> Bool:D)

在类型对象上返回 False，否则返回 True。

say Int.defined;                # OUTPUT: «False␤» 
say 42.defined;                 # OUTPUT: «True␤»

一些类型（如 Failure）会覆盖 defined，即使对于实例也是如此，也会返回 False

sub fails() { fail 'oh noe' };
say fails().defined;            # OUTPUT: «False␤»

例程定义§

multi defined(Mu --> Bool:D)

调用对象上的 .defined 方法并返回其结果。

例程 isa§

multi method isa(Mu $type     --> Bool:D)
multi method isa(Str:D $type  --> Bool:D)

如果调用者是类 $type 的实例、子集类型或 $type 的派生类（通过继承），则返回 True。 does 类似，但包括角色。

my $i = 17;
say $i.isa("Int");   # OUTPUT: «True␤» 
say $i.isa(Any);     # OUTPUT: «True␤» 
role Truish {};
my $but-true = 0 but Truish;
say $but-true.^name;        # OUTPUT: «Int+{Truish}␤» 
say $but-true.does(Truish); # OUTPUT: «True␤» 
say $but-true.isa(Truish);  # OUTPUT: «False␤»

例程 does§

method does(Mu $type --> Bool:D)

当且仅当调用者符合类型 $type 时，返回 True。

my $d = Date.new('2016-06-03');
say $d.does(Dateish);             # OUTPUT: «True␤»    (Date does role Dateish) 
say $d.does(Any);                 # OUTPUT: «True␤»    (Date is a subclass of Any) 
say $d.does(DateTime);            # OUTPUT: «False␤»   (Date is not a subclass of DateTime) 

与 isa 不同，后者仅对超类返回 True，does 包括超类和角色。

say $d.isa(Dateish); # OUTPUT: «False␤» 

使用智能匹配运算符 ~~ 是更习惯的替代方法。

my $d = Date.new('2016-06-03');
say $d ~~ Dateish;                # OUTPUT: «True␤» 
say $d ~~ Any;                    # OUTPUT: «True␤» 
say $d ~~ DateTime;               # OUTPUT: «False␤»

例程 Bool§

multi        Bool(Mu --> Bool:D)
multi method Bool(   --> Bool:D)

在类型对象上返回 False，否则返回 True。

许多内置类型会将其覆盖为 False，以表示空集合、空 字符串 或数字零

say Mu.Bool;                    # OUTPUT: «False␤» 
say Mu.new.Bool;                # OUTPUT: «True␤» 
say [1, 2, 3].Bool;             # OUTPUT: «True␤» 
say [].Bool;                    # OUTPUT: «False␤» 
say %( hash => 'full' ).Bool;   # OUTPUT: «True␤» 
say {}.Bool;                    # OUTPUT: «False␤» 
say "".Bool;                    # OUTPUT: «False␤» 
say 0.Bool;                     # OUTPUT: «False␤» 
say 1.Bool;                     # OUTPUT: «True␤» 
say "0".Bool;                   # OUTPUT: «True␤»

方法 Capture§

method Capture(Mu:D: --> Capture:D)

返回一个 Capture，其命名参数对应于调用者的公共属性

class Foo {
    has $.foo = 42;
    has $.bar = 70;
    method bar { 'something else' }
}.new.Capture.say; # OUTPUT: «\(:bar("something else"), :foo(42))␤»

方法 Str§

multi method Str(--> Str)

返回调用者的字符串表示形式，旨在供机器读取。方法 Str 会对类型对象发出警告，并生成空字符串。

say Mu.Str;   # Use of uninitialized value of type Mu in string context. 
my @foo = [2,3,1];
say @foo.Str  # OUTPUT: «2 3 1␤»

例程 gist§

multi        gist(+args --> Str)
multi method gist(   --> Str)

返回调用者的字符串表示形式，经过优化以供人类快速识别。因此，列表将被截断为 100 个元素。使用 .raku 获取所有元素。

Mu 中的默认 gist 方法会对已定义的调用者重新分派到 raku 方法，并对类型对象调用者返回括号中的类型名称。许多内置类会将实例的情况覆盖为更具体的内容，这可能会截断输出。

gist 是 say 隐式调用的方法，因此 say $something 和 say $something.gist 通常会生成相同的输出。

say Mu.gist;        # OUTPUT: «(Mu)␤» 
say Mu.new.gist;    # OUTPUT: «Mu.new␤»

方法 perl§

multi method perl(Mu:)

对调用者调用 .raku。由于语言名称已更改为 Raku，因此此方法已弃用，并且可能在不久的将来消失。请改用 .raku。

方法 raku§

multi method raku(Mu:U:)
multi method raku(Mu:D:)

对于类型对象，如果 .raku 尚未从 Mu 中重新定义，则返回其名称，否则对类型对象的名称调用 .raku。

say Str.raku;          # OUTPUT: «Str␤»

对于普通对象，它将按照惯例返回一个对象表示形式，该表示形式可通过 EVAL 使用来重建该对象的 value。

say (1..3).Set.raku;  # OUTPUT: «Set.new(1,2,3)␤»

方法 item§

method item(Mu \item:) is raw

强制在 item 上下文中对调用者进行求值并返回其 value。

say [1,2,3].item.raku;          # OUTPUT: «$[1, 2, 3]␤» 
say %( apple => 10 ).item.raku; # OUTPUT: «${:apple(10)}␤» 
say "abc".item.raku;            # OUTPUT: «"abc"␤»

方法 self§

method self(--> Mu)

返回对其调用的对象。

方法 clone§

multi method clone(Mu:U: *%twiddles)
multi method clone(Mu:D: *%twiddles)

此方法将克隆类型对象，或在使用任何参数调用它时终止。

say Num.clone( :yes )
# OUTPUT: «(exit code 1) Cannot set attribute values when cloning a type object␤  in block <unit>␤␤» 

如果使用 value 对象调用它，它将创建调用者的浅层克隆，包括私有属性的浅层克隆。可以通过命名参数（其名称与属性名称匹配）为公共属性提供备用 value。

class Point2D {
    has ($.x, $.y);
    multi method gist(Point2D:D:) {
        "Point($.x, $.y)";
    }
}
 
my $p = Point2D.new(x => 2, y => 3);
 
say $p;                     # OUTPUT: «Point(2, 3)␤» 
say $p.clone(y => -5);      # OUTPUT: «Point(2, -5)␤» 

请注意，.clone 不会进一步浅层复制 @. 和 %. sigiled 属性，并且如果修改，修改仍然可以在原始对象中使用

class Foo {
    has $.foo is rw = 42;
    has &.boo is rw = { say "Hi" };
    has @.bar       = <a b>;
    has %.baz       = <a b c d>;
}
 
my $o1 = Foo.new;
with my $o2 = $o1.clone {
    .foo = 70;
    .bar = <Z Y>;
    .baz = <Z Y X W>;
    .boo = { say "Bye" };
}
 
# Hash and Array attribute modifications in clone appear in original as well: 
say $o1;
# OUTPUT: «Foo.new(foo => 42, bar => ["Z", "Y"], baz => {:X("W"), :Z("Y")}, …␤» 
say $o2;
# OUTPUT: «Foo.new(foo => 70, bar => ["Z", "Y"], baz => {:X("W"), :Z("Y")}, …␤» 
$o1.boo.(); # OUTPUT: «Hi␤» 
$o2.boo.(); # OUTPUT: «Bye␤» 

要克隆它们，您可以实现自己的 .clone，该 .clone 克隆适当的属性并将新 value 传递给 Mu.clone，例如，通过 nextwith。

class Bar {
    has $.quux;
    has @.foo = <a b>;
    has %.bar = <a b c d>;
    method clone { nextwith :foo(@!foo.clone), :bar(%!bar.clone), |%_  }
}
 
my $o1 = Bar.new( :42quux );
with my $o2 = $o1.clone {
    .foo = <Z Y>;
    .bar = <Z Y X W>;
}
 
# Hash and Array attribute modifications in clone do not affect original: 
say $o1;
# OUTPUT: «Bar.new(quux => 42, foo => ["a", "b"], bar => {:a("b"), :c("d")})␤» 
say $o2;
# OUTPUT: «Bar.new(quux => 42, foo => ["Z", "Y"], bar => {:X("W"), :Z("Y")})␤» 

需要 |%_ 来吸收其余的属性，这些属性原本会通过浅层复制进行复制。

方法 new§

multi method new(*%attrinit)

用于构造（创建 + 初始化）某个类的对象的新默认方法。此方法仅期望命名参数，然后使用这些参数来使用同名访问器初始化属性。

类可以提供自己的 new 方法来覆盖此默认方法。

如果存在，new 会触发一个对象构造机制，该机制会调用继承层次结构中每个类的名为 BUILD 的子方法。有关更多信息，请参阅 有关对象构造的文档。

方法 bless§

method bless(*%attrinit --> Mu:D)

低级对象构造方法，通常从 new 中调用，隐式从默认构造函数中调用，或者在您创建自己的构造函数时显式调用。bless 使用命名参数初始化属性并返回创建的对象，创建与调用者相同类型的新对象。

通常在自定义 new 方法实现中调用

class Point {
    has $.x;
    has $.y;
    multi method new($x, $y) {
        self.bless(:$x, :$y);
    }
}
my $p = Point.new(-1, 1);

在此示例中，我们声明此 new 方法以避免在创建对象时使用对的额外语法。self.bless 返回对象，而对象又由 new 返回。new 被声明为 multi 方法，以便我们仍然可以使用默认构造函数，如下所示：Point.new( x => 3, y => 8 )。

有关更多详细信息，请参阅 有关对象构造的文档。

方法 CREATE§

method CREATE(--> Mu:D)

分配与调用者相同类型的新对象，而不初始化任何属性。

say Mu.CREATE.defined;  # OUTPUT: «True␤»

方法 print§

multi method print(--> Bool:D)

使用 .Str 方法将值打印到 $*OUT，而不会在末尾添加换行符。

"abc\n".print;          # OUTPUT: «abc␤»

方法 put§

multi method put(--> Bool:D)

将值打印到 $*OUT，在末尾添加换行符，并在必要时使用 .Str 方法将非 Str 对象字符串化。

"abc".put;              # OUTPUT: «abc␤»

方法 say§

multi method say()

将 say 到 标准输出。

say 42;                 # OUTPUT: «42␤»

因此，say 实际执行的操作被推迟到实际子类。在 大多数情况下，它对对象调用 .gist，返回一个紧凑的字符串表示形式。

在非接收器上下文中，say 始终会返回 True。

say (1,[1,2],"foo",Mu).map: so *.say ;
# OUTPUT: «1␤[1 2]␤foo␤(Mu)␤(True True True True)␤»

但是，此行为只是约定俗成的，您不应该相信它适用于您的代码。然而，它有助于解释某些行为。

say 首先在 *.say 中打印，但最外层的 say 正在打印 so 操作返回的 True 值。

方法 ACCEPTS§

multi method ACCEPTS(Mu:U: $other)

ACCEPTS 是使用 中缀 ~~ 运算符进行智能匹配的方法，并在右侧（匹配器）上调用 given/when。

Mu:U multi 执行类型检查。如果 $other 符合调用者（始终是类型对象或失败），则返回 True。

say 42 ~~ Mu;           # OUTPUT: «True␤» 
say 42 ~~ Int;          # OUTPUT: «True␤» 
say 42 ~~ Str;          # OUTPUT: «False␤»

请注意，对于已定义的调用者没有多重；这是为了允许自动线程化连接，当没有可用的直接候选者可调度时，它作为后备机制发生。

方法 WHICH§

multi method WHICH(--> ObjAt:D)

返回类型为ObjAt的对象，它唯一标识该对象。值类型覆盖此方法，该方法确保两个等效对象从WHICH返回相同返回值。

say 42.WHICH eq 42.WHICH;       # OUTPUT: «True␤»

方法 WHERE§

method WHERE(Mu:)

返回表示对象内存地址的Int。请注意，在 Raku 的 Rakudo 实现中，以及其他实现中，对象的内存位置不是对象生命期的固定值。因此，它对应用程序的使用有限，并且仅用作调试工具。

方法 WHY§

multi method WHY(Mu: --> Pod::Block::Declarator)

返回附加的 Pod::Block::Declarator。

例如

#| Initiate a specified spell normally 
sub cast(Spell $s) {
  do-raw-magic($s);
}
#= (do not use for class 7 spells) 
say &cast.WHY;
# OUTPUT: «Initiate a specified spell normally␤(do not use for class 7 spells)␤» 

有关将 Pod 附加到变量、类、函数、方法等的详细信息，请参阅Pod 声明符块。

特征 is export§

multi trait_mod:<is>(Mu:U \type, :$export!)

将类型标记为已导出，即对外部用户可用。

my class SomeClass is export { }

模块或类的用户会自动获取所有标记为is export的导入符号。

有关更多详细信息，请参阅导出和选择性导入模块。

方法 return§

method return()

方法return将停止子例程或方法的执行，运行所有相关的移相器，并将调用者作为返回值提供给调用者。如果提供了返回类型约束，则会对其进行检查，除非返回值为Nil。会引发控制异常，可以使用CONTROL捕获该异常。

sub f { (1|2|3).return };
say f(); # OUTPUT: «any(1, 2, 3)␤»

方法 return-rw§

与方法return相同，但return-rw会向调用者返回一个可写容器（有关更多详细信息，请参阅此处：return-rw）。

方法 emit§

method emit()

将调用者发送到封闭的供应或反应块中。

react { whenever supply { .emit for "foo", 42, .5 } {
    say "received {.^name} ($_)";
}}
 
# OUTPUT: 
# received Str (foo) 
# received Int (42) 
# received Rat (0.5)

方法 take§

method take()

返回封闭收集块中的调用者。

sub insert($sep, +@list) {
    gather for @list {
        FIRST .take, next;
        take slip $sep, .item
    }
}
 
say insert ':', <a b c>;
# OUTPUT: «(a : b : c)␤»

例程 take§

sub take(\item)

获取给定项并将其传递到封闭的 gather 块。

#| randomly select numbers for lotto 
my $num-selected-numbers = 6;
my $max-lotto-numbers = 49;
gather for ^$num-selected-numbers {
    take (1 .. $max-lotto-numbers).pick(1);
}.say;    # six random values

例程 take-rw§

sub take-rw(\item)

将给定项返回到封闭的 gather 块，而不会引入新的容器。

my @a = 1...3;
sub f(@list){ gather for @list { take-rw $_ } };
for f(@a) { $_++ };
say @a;
# OUTPUT: «[2 3 4]␤»

方法 so§

method so()

在布尔语境中评估项（因此，例如，折叠连接），并返回结果。它是 not 的相反，并且等效于 ? 运算符。

可以类似于英语句子使用此方法：“如果如此，则执行此操作”。例如，

my @args = <-a -e -b -v>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if $verbose-selected.so {
    say "Verbose option detected in arguments";
} # OUTPUT: «Verbose option detected in arguments␤»

在这种情况下，$verbose-selected 变量包含一个 Junction，其值为 any(any(False, False), any(False, False), any(False, False), any(True, False))。那实际上是一个真值；因此，否定它将产生 False。该结果的否定将是 True。so 在幕后执行所有这些操作。

方法 not§

method not()

在布尔语境中评估项（例如，导致连接的最终评估），并否定结果。它是 so 的相反，其行为等效于 ! 运算符。

my @args = <-a -e -b>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if $verbose-selected.not {
    say "Verbose option not present in arguments";
} # OUTPUT: «Verbose option not present in arguments␤»

由于还有 not 的前缀版本，因此此示例的读法更好

my @args = <-a -e -b>;
my $verbose-selected = any(@args) eq '-v' | '-V';
if not $verbose-selected {
    say "Verbose option not present in arguments";
} # OUTPUT: «Verbose option not present in arguments␤»

类型图§

Mu 的类型关系
raku-type-graph Mu Mu Any Any Any->Mu Junction Junction Junction->Mu

展开上面的图表