类 Parameter

签名元素

class Parameter { }

表示参数，用于内省。

获取 Parameter 对象的常用方法是创建签名，然后在其上调用 .params 以获取参数列表。

my $sig   = :(Str $x);
my $param = $sig.params[0];
say $param.type;              # OUTPUT: «Str()␤»

有关更多信息，以及对与参数相关的大多数概念的解释，请参阅 Signature。

方法§

方法名称§

method name(Parameter:D: --> Str:D)

返回参数名称，其中包括所有 符号 和 twigils。在应用于代码或在声明中确定声明的名称时，内部使用此名称。此名称不一定可供调用者使用 – 如果可以，它还将显示为 别名。通常，名称将以描述性方式选择，作为自文档的一种形式。

如果参数是匿名的，则将返回一个空字符串。

注意：在 Rakudo 2020.08 版本之前，匿名参数的返回值为 Nil。

my Signature $sig = :(Str $x, Bool);
say $sig.params[0].name;                 # OUTPUT: «$x␤» 
say $sig.params[1].name;                 # OUTPUT: «␤» 

方法使用名称§

method usage-name(Parameter:D: --> Str:D)

返回不带任何 符号 和 twigils 的参数名称。

如果参数是匿名的，则将返回一个空字符串。

注意：在 Rakudo 2020.08 版本之前，匿名参数的返回值为 Nil。

my Signature $sig = :(Str $x, Str @*l, Bool);
say $sig.params[0].usage-name;           # OUTPUT: «x␤» 
say $sig.params[1].usage-name;           # OUTPUT: «l␤» 
say $sig.params[2].usage-name;           # OUTPUT: «␤» 

方法符号§

method sigil(Parameter:D: --> Str:D)

返回一个包含参数符号的字符串，对于“符号”的定义比参数 name 中所考虑的定义更宽松。即使参数是匿名的，也会返回符号。

此“符号”实际上是一个内省，用于帮助确定参数的正常绑定样式，如果它尚未通过 特征 进行更改。

符号将绑定到默认行为
$标量生成新的标量，在参数中使用，如果有的话
@位置直接绑定到参数
@位置绑定故障转移如果绑定失败，则调用参数的 .cache 方法，绑定到结果
%关联直接绑定到参数
&可调用直接绑定到参数
\（任何）直接绑定到参数，保留现有的标量（如果有）

此外，| 将绑定到所有剩余参数，并在需要时创建新的 Capture。

方法类型§

返回参数的 标称类型约束。

方法 coerce_type§

返回参数的强制转换类型。

方法 constraints§

返回参数的附加约束（通常作为all-Junction）。

方法 named§

method named(Parameter:D: --> Bool:D)

如果它是一个命名参数，则返回True。

my Signature $sig = :(Str $x, Bool :$is-named);
say $sig.params[0].named;                          # OUTPUT: «False␤» 
say $sig.params[1].named;                          # OUTPUT: «True␤»

方法 named_names§

method named_names(Parameter:D: --> List:D)

返回命名参数的外部可用名称/别名的列表。

方法 positional§

method positional(Parameter:D: --> Bool:D)

如果参数是位置参数，则返回True。

my Signature $sig = :(Str $x, Bool :$is-named);
say $sig.params[0].positional;                     # OUTPUT: «True␤» 
say $sig.params[1].positional;                     # OUTPUT: «False␤»

方法 slurpy§

method slurpy(Parameter:D: --> Bool:D)

对于slurpy 参数返回True。

方法 twigil§

method twigil(Parameter:D: --> Str:D)

返回一个包含参数名称的 twigil 部分的字符串。

方法 optional§

method optional(Parameter:D: --> Bool:D)

对于可选参数返回True。

方法 raw§

method raw(Parameter:D: --> Bool:D)

对于原始参数返回True。

sub f($a, $b is raw, \c) {
    my $sig = &?ROUTINE.signature;
    for ^$sig.params.elems {
        say $sig.params[$_].raw;
    }
}
f(17, "4711", 42); # OUTPUT: «False␤True␤True␤»

原始参数绑定传递给它的变量或值，不会进行解容器化。这意味着如果一个变量传递给它，你可以分配给参数。这不同于rw参数，后者只能绑定到变量，而不能绑定到值。

这是使用'\' sigil声明的参数的正常行为，它实际上不是一个 sigil，因为它仅用于参数。

sub f(\x) {
    x = 5;
}
f(my $x);   # works 
f(42);      # dies 
CATCH { default { put .^name, ': ', .Str } };
# OUTPUT: «X::Assignment::RO: Cannot modify an immutable Int␤»

其他参数可以通过使用'is raw' trait变为原始参数。这些仍然在代码中使用它们的 sigil。

sub f($x is raw) {
    $x = 5;
}

当与 slurpy 列表参数一起使用时，is raw trait 将导致给定的参数列表打包到List中，而不是Array中，这可以防止它们与Scalar一起容器化。这是使用 sigilless 参数与 + 一起使用时的默认行为

my @types is List = Mu, Any;
say -> *@l { @l }(@types)[0] =:= @types[0];        # OUTPUT: «False␤» 
say -> +@l { @l }(@types)[0] =:= @types[0];        # OUTPUT: «False␤» 
say -> +l { l }(@types)[0] =:= @types[0];          # OUTPUT: «True␤» 
say -> *@l is raw { @l }(@types)[0] =:= @types[0]; # OUTPUT: «True␤»

方法 capture§

method capture(Parameter:D: --> Bool:D)

对于将参数列表的其余部分捕获到单个Capture对象中的参数，返回True。

sub how_many_extra_positionals($!, |capture) { capture.elems.say }
how_many_extra_positionals(0, 1, 2, 3);                        # OUTPUT: «3␤» 
say &how_many_extra_positionals.signature.params[1].capture;   # OUTPUT: «True␤»

与原始参数类似，Capture参数不会强制对绑定到它们的值进行任何上下文，这就是为什么它们的 sigil 仅在声明中使用。

方法 rw§

method rw(Parameter:D: --> Bool:D)

对 is rw 参数返回 True。

my Signature $sig = :(Str $x is rw, Bool :$is-named);
say $sig.params[0].rw;                             # OUTPUT: «True␤» 
say $sig.params[1].rw;                             # OUTPUT: «False␤»

method copy§

method copy(Parameter:D: --> Bool:D)

对 is copy 参数返回 True。

my Signature $sig = :(Str $x, Bool :$is-named is copy);
say $sig.params[0].copy;                           # OUTPUT: «False␤» 
say $sig.params[1].copy;                           # OUTPUT: «True␤»

method readonly§

method readonly(Parameter:D: --> Bool:D)

对只读参数（默认）返回 True。

my Signature $sig = :(Str $x is rw, Bool :$is-named);
say $sig.params[0].readonly;                       # OUTPUT: «False␤» 
say $sig.params[1].readonly;                       # OUTPUT: «True␤»

method invocant§

method invocant(Parameter:D: --> Bool:D)

如果参数是 调用者参数，则返回 True。

my Signature $sig = :($i : Str $x is rw, Bool :$is-named);
say $sig.params[0].invocant;                       # OUTPUT: «True␤» 
say $sig.params[1].invocant;                       # OUTPUT: «False␤»

method default§

method default(Parameter:D: --> Code:_)

返回一个闭包，在调用时返回此参数的 默认值，或者如果没有提供默认值，则返回 Code。

注意：在 Rakudo 2020.08 版本之前，没有默认值的返回参数是 Any。

my $sig = :($a, $b = 12);
say $sig.params[0].default;        # OUTPUT: «(Code)␤» 
say $sig.params[1].default.();     # OUTPUT: «12␤» 

method type_captures§

method type_captures(Parameter:D: --> List:D)

返回与此参数关联的 类型捕获 的变量名称列表。类型捕获在附加代码中定义一个类型名称，该名称是调用期间从参数中收集的类型的别名。

sub a(::T $x) { T.say }
a(8);                                       # OUTPUT: «(Int)␤» 
say &a.signature.params[0].type_captures;   # OUTPUT: «(T)␤» 
sub b($x) { $x.^name.say }
a(8);                                       # OUTPUT: «Int␤»

使用的类型可能会因调用而异。一旦定义，类型捕获可以在任何使用类型的地方使用，甚至在同一签名中稍后使用

sub c(::T $x, T $y, $z) { my T $zz = $z };
c(4, 5, 6);          # OK 
 
try c(4, 5, "six");
given $! { .message.say };
# OUTPUT: «Type check failed in assignment to $zz; expected Int but got Str ("six")␤» 
 
try c("four", 5, "six");
given $! { .message.say };
# OUTPUT: «Type check failed in binding to parameter '$y'; expected Str but got Int (5)␤» 

类型捕获可以与 类型约束 同时使用。

sub d(::T Numeric $x, T $y) {};
d(4, 5);            # OK 
d(4e0, 5e0);        # OK 
 
try d(4e0, 5);
given $! { .message.say };
# OUTPUT: «Type check failed in binding to parameter '$y'; expected Num but got Int (5)␤» 
 
try d("four", "five");
given $! { .message.say };
# OUTPUT: «Type check failed in binding to parameter '$x'; expected Numeric but got Str ("four")␤» 

method sub_signature§

method sub_signature(Parameter:D: --> Signature:_)

如果参数有 子签名，则返回一个 Signature 对象。否则返回 Signature。

注意：在 Rakudo 2020.08 版本之前，没有子签名的返回参数是 Any。

my Signature $sig = :(@array ($first, *@rest), @other);
say $sig.params[0].sub_signature;     # OUTPUT:«($first, *@rest)␤» 
say $sig.params[1].sub_signature;     # OUTPUT:«(Signature)␤» 

method prefix§

method prefix(Parameter:D: --> Str:D)

如果参数是 贪婪 的，则返回参数声明时使用的标记（例如，*、** 或 +）。否则，返回空字符串。

my Signature $flat-slurpy = :($a, *@b);
say $flat-slurpy.params[0].prefix; # OUTPUT:«␤» 
say $flat-slurpy.params[1].prefix; # OUTPUT:«*␤» 
 
my Signature $unflat-slurpy = :($a, **@b);
say $unflat-slurpy.params[0].prefix; # OUTPUT:«␤» 
say $unflat-slurpy.params[1].prefix; # OUTPUT:«**␤» 
 
my Signature $sar-slurpy = :($a, +@b);
say $sar-slurpy.params[0].prefix; # OUTPUT:«␤» 
say $sar-slurpy.params[1].prefix; # OUTPUT:«+␤»

method suffix§

method suffix(Parameter:D: --> Str:D)

返回参数声明时使用的 ? 或 ! 标记（如果存在）。否则，返回空字符串。

my Signature $pos-sig = :($a, $b?);
say $pos-sig.params[0].suffix; # OUTPUT: «␤» 
say $pos-sig.params[1].suffix; # OUTPUT: «?␤» 
 
my Signature $named-sig = :(:$a!, :$b);
say $named-sig.params[0].suffix; # OUTPUT: «!␤» 
say $named-sig.params[1].suffix; # OUTPUT: «␤»

method modifier§

method modifier(Parameter:D: --> Str:D)

返回参数声明时使用的 类型笑脸（:U、:D 或 :_）。它为 :_ 类型笑脸返回空字符串。

my Signature $sig = :(Str:U $a, UInt:D $b, $c);
say $sig.params[0].modifier; # OUTPUT: «:U␤» 
say $sig.params[1].modifier; # OUTPUT: «:D␤» 
say $sig.params[2].modifier; # OUTPUT: «␤»

Parameter 对象的运行时创建（6.d、2019.03 及更高版本）§

Parameter.new( ... )

在某些情况下，特别是在使用 元对象协议 时，以编程方式创建 Parameter 对象是有意义的。为此，您可以使用以下命名参数调用 new 方法

  • name

可选。参数的名称（如果有）。可以按 Signature 中的方式指定。因此它可能包含特定的附加信息，例如符号（$、@、% 或 &）、: 前缀以指示命名参数、twigil（. 或 !）以指示公有/私有属性绑定、后缀 ! 或 ? 以指示可选/强制参数，以及 +、*、** 前缀的各种组合以指示 slurpiness 类型和 | 以指示 Capture。

  • 类型

可选。参数的类型。如果未指定，则假定为 Any。

  • 默认

可选。如果参数是可选的，且未为该参数提供任何参数，则为参数的值。如果未提供任何参数，则假定未初始化，这将回退到参数的（隐式）类型。

  • 位置

可选。要应用于任何参数以与该参数匹配的附加约束。默认情况下不设置任何附加约束。

  • is-copy

可选。允许在参数上设置“is copy”标志。默认情况下不设置标志。

  • is-raw

可选。允许在参数上设置“is raw”标志。默认情况下不设置标志。

  • is-rw

可选。允许在参数上设置“is rw”标志。默认情况下不设置标志。

  • 命名

可选。指示参数是否为命名参数。仅当名称中未指定 : 前缀且需要命名参数时才应指定。

  • 可选

可选。指示参数是否为可选参数。仅当名称中未指定 ? 后缀且需要可选参数时才应指定。

  • 强制

可选。指示参数是否为强制参数。仅当名称中未指定 ! 后缀且需要强制参数时才应指定。

  • 多调用

可选。指示是否在多重分派中考虑参数。默认为 True，因此需要执行 :!multi-invocant 才能使参数不被考虑在多重分派中。

  • 子签名

可选。指定应应用于参数以对其进行解构的任何 Signature。默认情况下，不应用任何签名。

Typegraph§

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

展开上面的图表