匿名

子例程、方法或子方法，当它们不能通过名字调用时，就被称为匿名的

  1. # named subroutine
  2. sub double($x) { 2 * $x };
  3. # 匿名子例程,存储在一个具名的标量里
  4. my $double = sub ($x) { 2 * $x };

注意，匿名子例程仍然可以有名字

  1. # 使用 anon 关键字使子例程匿名
  2. my $s = anon sub triple($x) { 3 * $x }
  3. say $s.name;        # triple

副词

通常, 副词是函数的命名参数. 也有一些其它特殊语法形式允许副词出现在某些合适的地方:

  1. q:w"foo bar"   # ":w" is a Quotelike form modifier adverb
  2. m:g/a|b|c/     # ":g" is also
  3. 4 +> 5 :rotate # ":rotate" is an operator adverb
  4. @h{3}:exists   # ":exists" is also, but is known as a subscript adverb

副词通常使用冒号对儿标记来表示, 因为这个原因, 冒号对儿标记法也以副词对儿形式著称:

  1. :a(4)          # Same as "a" => 4

Autothreading

Autothreading 是这样的: 如果你传递一个 junction 给子例程, 该子例程期望的参数类型为`Any` 或它的子类型. 那么这个子例程调用会被执行多次, 每次使用一个不同的 junction 状态. 这些调用的结果被组合成一个跟原 junction 同类型的 junction.

  1. sub f($x) { 2 * $x };
  2. if f(1|2|3) == 4 {
  3.     say 'success';
  4. }

这里 f() 是含有一个参数的子例程，然而因为它没有显式的类型声明，它就被隐式的声明为 Any 型。 Junction 参数使 f(1|2|3) 调用在内部作为 f(1)|f(2)|f(3) 执行,而结果是跟原 junction 同类型的 junction , 即 2|4|6. 这种把一个 Junction 分成对多次函数调用的处理就叫做 autothreading.

Colon Pair and Colon List

冒号对儿是用于创建或 Pair 对象的便捷语法. 两种最常见的形式是:

  1. :a(4)          # Same as "a" => 4,   same as Pair.new(:key<a>,:value(5))
  2. :a<4>          # Same as "a" => "4", same as Pair.new(:key<a>,:value<5>)

这也是人们熟知的副词对儿形式. 注意, 当冒号后面括号前面的部分不是一个合法的标识符的时候, 会应用其它语义, 不是所有的副词对儿都创建 Pair 对象. 另外两个常见的形式是:

  1. :a             # Same as :a(True)
  2. :!a            # Same as :a(False)

一个 colon 列表是一个仅包含冒号对儿的列表, 不需要逗号, 甚至不需要空格:

  1. :a(4):c:!d:c   # Same as a => 4, c => True, d => False, c => True

Constraint

约束是给参数或 subset 类型添加的限制. 通过单词 where 引入约束. 在下面的例子中, 约束用于确保 , 当调用一个名为 abbreviate 的子例程, 其参数为一个长度小于 10 个字符的字符串时,会抛出一个错误:

  1. sub abbreviate (Str $thing where { .chars >= 10 }) { ... }

上例中的 Str 也是一个约束, 但是经常作为”类型约束”.

Instance

类的实例在其它编程语言中也叫对象. 对象存储属性, 通常是 new 方法调用的返回值, 或者是对象字面量. 大部分类型的实例被定义为 True, 例如 defined($instance) 为 True.

  1. my Str $str = "hello";  ## 这使用内建类型,例如 Str
  2. if defined($str) {
  3.     say "Oh, yeah. I'm defined.";
  4. } else {
  5.     say "No. Something off? ";
  6. }
  7. ## if you wanted objects...
  8. class A {
  9.     # nothing here for now.
  10. }
  11. my $an_instance = A.new;
  12. say $an_instance.defined.perl;# defined($an_instance) works too.

类拥有方法和属性的所有蓝图, 而类的实例把蓝图带到真实世界中.

Invocant

在 Raku 中调用方法的对象叫做调用者. 在方法中它就是 self 引用的东西.

  1. say 'str'.uc;   # 'str' 是 方法 uc 的调用者

Literal

字面量是一块直接代表对象的代码, 通常指向对象自身.

  1. my $x = 2;      # the 2 is a literal
  2. say $x;         # $x is not a literal, but a variable

lvalue

lvalue 或者左值是能出现在赋值操作符左侧的任何东西; 典型的左值有变量,私有属性和 `is rw`属性, 变量列表和左值子例程. 左值的例子:

  1. Declaration             lvalue          Comments
  2. my $x;                  $x
  3. my ($a, $b);            ($a, $b)
  4. has $!attribute;        $!attribute     Only inside classes
  5. has $.attrib is rw;     $.attrib
  6. sub a is rw { $x };     a()

不是左值的例子:

  1. 3                        # literals
  2. constant x = 3;          # constants
  3. has $.attrib;            # attributes; you can only assign to $!attrib
  4. sub f { }; f();          # "normal" subs are not writable
  5. sub f($x) { $x = 3 };    # error - parameters are read-only by default

Mainline

mainline 是程序中不属于任何 block 的程序文本.

  1. use v6;     # mainline
  2. sub f {
  3.             # not in mainline, in sub f
  4. }
  5. f();        # in mainline again

Slurpy

子例程或方法中的形参如果能接收任意数量的参数, 那这个形参就会被认为是 slurpy 的. 它由参数名字前面的星号标出.

  1. sub sum (*@numbers) {
  2.     return [+] @numbers;
  3. }

Type Object

类型对象是一个代表类 /role/package/grammar/enum 的对象. 它通常和类型名相同.

  1. class A { };
  2. say A;              # A is the type object
  3. my $x = A.new();    # same here
  4. my $x = class {
  5.     method greet() {
  6.         say "hi";
  7.     }
  8. }
  10. # $x now holds a type object returned from the
  11. # anonymous class definition