Raku at a glance

Raku使用符号来标记变量。 这些符号部分兼容 使用Perl 5语法。 例如，标量，列表和散列分别使用$，@和％sigils。

代码打印42并不奇怪。

考虑以下片段，它也给出了可预测的结果（方括号表示一个数组）：

现在，让我们使用Raku的优点并重写上面的代码，使用更少的输入，更少的字符和更少的标点符号：

或者甚至像这样:

类似地，我们可以在初始化哈希时省略括号，留下裸内容：

这个小程序打印出这个（哈希键的顺序） 输出可能不同，你不应该依赖它）：

为了访问列表或散列的元素，Raku使用不同类型的括号。 重要的是要记住，印记始终保持不变。 在以下示例中，我们从列表和哈希中提取标量：

存在用于创建散列和访问其元素的替代语法。 要了解它是如何工作的，请检查下一段代码：

命名变量是一件相当有趣的事情，因为Raku不仅允许使用ASCII字母，数字和下划线字符，还允许使用许多UTF-8元素，包括连字符和撇号：

由于内省的机制，很容易告诉变量中的数据类型（Raku中的变量通常被称为容器）。 为此，请在变量上调用预定义的WHAT方法。 即使它是一个裸标量，Raku也会在内部将其视为一个对象; 因此，你可以在上面调用一些方法。 对于标量，结果取决于驻留在变量中的实际数据类型。 这是一个例子（括号是输出的一部分）： 使用非拉丁字符变量名称没有任何性能影响。 但如果你做，总是想到那些可能需要阅读你的代码的开发人员在将来

你是否更喜欢变量名称中的非拉丁字符？ 虽然它可能会降低打字的速度，因为它需要切换键盘布局， 。

这是你如何声明一个带类型的变量的:

这里，标量容器 $x 可能只包含整数值。 尝试去为它分配一个非整数的值会导致错误：

对于类型转换，相应的方法调用非常方便。 请记住，虽然$x包含一个整数，但它被视为一个整体的容器对象，这就是为什么你可以在它上面使用一些预定义的方法。 你可以直接在字符串上执行相同的操作。 例如：

Raku对象（即所有变量）包含Bool方法，该方法将变量的值转换为两个布尔值之一：

类似地，你可以在变量上调用Int方法并获取整数 布尔值的表示（或任何其他类型的值）：

Int 类型用于承载任意大小的整数变量。 例如，以下任务中没有数字丢失：

存在一种特殊语法，用于定义具有10个以上基数的整数：

此外，允许使用下划线字符分隔数字，以便更容易读取大数字：

当然，当你打印该值时，所有下划线都消失了。 在Int对象上，你可以调用一些其他方便的方法，例如，将数字转换为字符或检查手中的整数是否为素数（是的，is-prime 是内置方法！）。

Str 毫无疑问是一个字符串。 在 Raku 中，有一些操作字符串的方法。 再次，你将它们称为对象上的方法。

现在让我们得到一个字符串的长度。 编写 $str.length的天真尝试会产生错误消息。 但是，还提供了一个提示：

因此，我们有一个简单的单语义方法来获取Unicode字符串的长度。

习惯使用字符串作为对象的新方法可能需要一些时间。 例如，这是如何将printf作为字符串上的方法调用的：

Array变量（即所有以@sigil开头的变量）都配备了一些简单但相当有用的方法。

如果打印数组，则将其值作为方括号中以空格分隔的列表。 或者，你可以将其插入字符串中。

哈希提供了一些具有明确语义的方法，例如：

这里是输出:

不仅可以遍历散列键或值，还可以遍历整个对：

! 是布尔否定运算符。

not 运算符执行相同但优先级较低。

+ 是一元加运算符，它将操作数转换为数字上下文。 该操作等同于Numeric方法的调用。

我们将在第6章中看到一元加的一个重要用例：+$/。 该构造将Match类的对象转换为数字，该对象包含有关正则表达式的匹配部分的信息。

? 是一个一元运算符，通过调用，将上下文转换为布尔值Bool方法对象。

第二种形式, so, 是一个一元运算符, 其优先级更低。

~ 将对象强制转换为字符串。 请注意，我们现在正在讨论前缀或一元运算符。 如果代字号被用作中缀（参见本章后面有关什么是中缀），它可以作为字符串连接运算符，但它仍然处理字符串。

在某些情况下，可以隐式创建字符串上下文，例如，当你在双引号内插入变量时。

++ 是增量的前缀运算符。 首先，完成增量，然后返回一个新值。

增量操作不仅限于使用数字。它也可以处理字符串。

一个实际的例子是增加包含数字的文件名。 文件扩展名将继续存在，并且只会增加数字部分。

 — 是减量的前缀形式。 它的工作方式与++前缀完全相同，但当然会使操作数更小（无论是字符串还是数字）。

+^ 是具有二进制补码的按位求反运算符。

将此运算符与以下运算符进行比较。

?^ 是逻辑否定运算符。 请注意，这不是一个按位否定。 首先，将参数转换为布尔值，然后否定结果。

^是范围创建运算符或所谓的upto运算符。 它创建一个范围（它是Range类型的一个对象），从0到给定值（不包括它）。

此代码等效于以下范围的两端明确指定：

| 将复合对象展平为列表。 例如，当你将列表传递给子例程时，应该使用此运算符，子例程需要一个标量列表：

如果没有 | 运算符，编译器将报告错误，因为子例程需要两个标量，并且不能接受数组作为参数：

temp 创建一个临时变量并在范围的末尾恢复其值（就像它在Perl 5中的本地内置运算符一样）。

将它与以下运算符进行比较，let。

let 是一个前缀运算符，类似于temp，但可以正常使用异常。 如果由于异常而留下范围，则将恢复变量的先前值。

使用 die，此示例代码将打印初始值a。 如果注释掉骰子的调用，则对b的赋值的效果将保持不变，并且该变量将包含try块之后的值b。 let 关键字看起来类似于我和我们的声明符，但它是一个前缀运算符。

++ 是一个后缀增量。 在表达式中使用当前值之后，将更改值。

 — 是后缀自减。

postfix和prefix运算符都神奇地知道如何处理文件名中的数字。

此示例使用递增的数字打印文件名列表：file01.txt，file02.txt，…​ file10.txt。

.method 在变量上调用方法。 这适用于真实对象和那些不是任何类的实例的变量，例如整数等内置类型。

.=method 是对象的方法的变异调用。 调用 $x.=method 与更详细的任务相同 $x = $x.method。 在下面的示例中，$o容器最初包含C类的对象，但在$o.=m()之后，该值将替换为D类的实例。

这里，$o 对象在它自己的B类和它的类中都有m方法,父类A. $o.+m(7) 调用这两种方法并将其结果放入列表中。 如果未定义方法，则将引发异常。

Subroutines, or subs For a sub, which takes no arguments, its definition and the call are very straightforward and easy. sub call+me { say "I’m called" } call+me;

The syntax for declaring a sub’s parameters is similar to what other lan- guages (including Perl 5.20 and higher) provide. sub cube($x) { return $x ** 3; } say cube(3); # 27 The required parameters are a comma-separated list in the parentheses immediately after the sub name. No other keywords, such as my, are required to declare them. sub min($x, $y) { return $x < $y ?? $x $y; }

say min(2, 2); # -2 say min(42, 24); # 24 (?? ... is a ternary operator in Raku. Also, there’s a built-in opera- tor min; see the details in the Chapter 2.) The above-declared arguments are required; thus, if a sub is called with a different number of actual arguments, an error will occur. 58 Non-value argument passing By default, you pass the arguments by their values. Despite that, it is not possible to modify them inside the sub. To pass a variable by refer- ence, add the is rw trait. (Note that formally this is not a reference but a mutable argument.) sub inc($x is rw) { $x+; }

my $value = 42; inc($value); say $value; # 43 Typed arguments Similarly to the above-described typed variables, it is possible to indi- cate that the sub’s parameters are typed. To do so, add a type name before the name of the parameter. sub say+hi(Str $name) { say "Hi, $name "; } If the types of the expected and the actual parameters do not match, a compile-time error will occur. say+hi("Mr. X"); # OK # say+hi(123); # Error: Calling say-hi(Int) will never work # with declared signature (Str $name) Optional parameters Optional parameters are marked with a question mark after their names. The defined built-in function helps to tell if the parameter was really passed:

59

sub send+mail(Str $to, Str $bcc?) { if defined $bcc { # . . . say "Sent to $to with a bcc to $bcc."; } else { # . . . say "Sent to $to."; } }

send+mail('mail@example.com'); send+mail('mail@example.com', 'copy@example.com'); Default values Raku also allows specifying the default values of the sub’s arguments. Syntactically, this looks like an assignment. sub i+live+in(Str $city = "Moscow") { say "I live in $city."; }

i+live+in('Saint Petersburg'); i+live+in(); # The default city It is also possible to pass values that are not known at the compile phase. When the default value is not a constant, it will be calculated at runtime. sub to+pay($salary, $bonus = 100.rand) { return ($salary + $bonus).floor; }

say to+pay(500, 50); # Always 550 net. say to+pay(500); # Any number between 500 and 600. say to+pay(500); # Same call but probably different output. The “default” value will be calculated whenever it is required. Please also note that both rand and floor are called as methods, not as func- tions. 60

sub f($a, $b = $a) { say $a + $b; }

f(42); # 84 f(42, +1) # 41 Optional parameters or parameters with default values must be listed after all the required ones because otherwise, the compiler will not be able to understand which is which. Named arguments Apart from the positional parameters (those that have to go in the same order both in the sub definition and in the sub call), Raku allows named variables, somewhat similar to how you pass a hash to a Perl 5 subroutine. To declare a named parameter, a semicolon is used: sub power(:$base, :$exponent) { return $base $exponent; } Now, the name of the variable is the name of the parameter, and the order is not important anymore. say power(:base(2), :exponent(3)); # 8 say power(:exponent(3), :base(2)); # 8 It is also possible to have different names for the named arguments and those variables, which will be used inside the sub. To give a different name, put it after a colon: sub power(:val($base), :pow($exponent)) { return $base $exponent; } Now the sub expects new names of the arguments.

61

say power(:val(5), :pow(2)); # 25 say power(:pow(2), :val(5)); # 25 Alternatively, you can use the fatarrow syntax to pass named parame- ters as it is done in the following example:

say power(val ⇒ 5, pow ⇒ 2); # 25 Slurpy parameters and flattening Raku allows passing scalars, arrays, hashes, or objects of any other type as the arguments to a sub. There are no restrictions regarding the com- bination and its order in a sub declaration. For example, the first argu- ment may be an array, and the second one may be a scalar. Raku will pass the array as a whole. Thus the following scalar will not be eaten by the array. In the following example, the @text variable is used inside the sub, and it contains only the values from the array passed in the sub call. sub cute+output(@text, $before, $after) { say $before ~ $_ ~ $after for @text; }

my @text = <C C Perl Go>; cute+output(@text, '{', '}'); The output looks quite predictable. {C}& {C}& {Perl}& {Go}& The language expects that the sub receives the arguments of the same types that were listed in the sub declaration. That also means, for example, that if the sub is declared with only one list argument, then it cannot accept a few scalars. 62

sub get+array(@a) { say @a; }

get+array(1, 2, 3); # Error: Calling get-array(Int, Int, Int) # will never work with declared signature (@a)

To let an array accept a list of separate scalar values, you need to say that explicitly by placing an asterisk before the argument name. Such an argument is called slurpy. sub get+array(*@a) { say @a; }

get+array(1, 2, 3); # Good: [1 2 3] Similarly, it will work in the opposite direction, that is to say, when the sub expects to get a few scalars but receives an array when called. sub get+scalars($a, $b, $c) { say "$a and $b and $c"; }

my @a = <3 4 5>; get+scalars(@a); # Error: Calling get-scalars(Positional) # will never work with declared # signature ($a, $b, $c) A vertical bar is used to unpack an array to a list of scalars. get+scalars(|@a); # 3 and 4 and 5

63

Nested subs Nested subs are allowed in Raku. sub cube($x) { sub square($x) { return $x * $x; } return $x * square($x); }

say cube(3); # 27 The name of the inner sub square is only visible within the body of the outer sub cube. Anonymous subs Let’s look at the creation of anonymous subs. One of the options (there are more than one) is to use syntax similar to what you often see in JavaScript. say sub ($x, $y) {$x ~ ' ' ~ $y}("Perl", 6); The first pair of parentheses contains the list of formal arguments of the anonymous sub; the second, the list of the arguments passed. The body of the sub is located between the braces. (The tilde denotes a string concatenation operator in Raku.) By the way, it is important that there be no spaces before parentheses with the actual values of the sub parameters. Another way of creating an anonymous sub is to use the arrow operator (+>). We will discuss it later in the section dedicated to anonymous blocks. 64

Variables and signatures Lexical variables Lexical variables in Raku are those declared with the my keyword. The- se variables are only visible within the block where they were declared. If you tried accessing them outside the scope, you’d get the error: Var+ iable '$x' is not declared. { my $x = 42; say $x; # This is fine } # say $x; # This is not

To “extend” the scope, lexical variables can be used in closures. In the following example, the seq sub returns a block, which uses a variable defined inside the sub. sub seq($init) { my $c = $init; return {$c++}; } The sub returns a code block containing the variable $c. After the sub’s execution, the variable will not only still exist but also will keep its val- ue, which you can easily see by calling a function by its reference a few times more. my $a = seq(1); say $a(); # 1 say $a(); # 2 say $a(); # 3 It is possible to create two independent copies of the local variable. my $a = seq(1); my $b = seq(42);

65

To see how it works, call the subs a few times:

say $a(); # 1 say $a(); # 2 say $b(); # 42 say $a(); # 3 say $b(); # 43 state variables State variables (declared with the keyword state) appeared in Perl 5.10 and work in Raku. Such variables are initialized during the first call and keep their values in subsequent sub calls. It is important to keep in mind that a single instance of the variable is created. Let us return to the example with a counter and replace the my declaration with the state one. The closure will now contain a refer- ence to the same variable. sub seq($init) { state $c = $init; return {$c++}; } What happens when you create more than one closure? my $a = seq(1); my $b = seq(42);

All of them will reference the same variable, which will increase after calling either $a() or $b(). say $a(); # 1 say $a(); # 2 say $b(); # 3 say $a(); # 4 say $b(); # 5 66

Dynamic variables The scope of dynamic variables is calculated at the moment when a variable is accessed. Thus, two or more calls of the same code may pro- duce different results. Dynamic variables are marked with the * twigil (a character clearly ref- erencing a wildcard). In the following example, the echo() function prints a dynamic variable $*var, which is not declared in the function, nor is it a global variable. It, nevertheless, can be resolved when used in other functions, even if they have their own instances of the variable with the same name.

sub alpha { my $*var = 'Alpha'; echo(); }

sub beta { my $*var = 'Beta'; echo(); }

sub echo() { say $*var; }

alpha(); # Alpha beta(); # Beta Anonymous code blocks Raku introduces the concept of so-called pointy blocks (or pointy ar- row blocks). These are anonymous closure blocks, which return a refer- ence to the function and can take arguments. The syntax of defining pointy blocks is an arrow +> followed by the ar- gument list and a block of code.

67

my $cube = +> $x {$x ** 3}; say $cube(3); # 27

Here, the block {$x 3}, which takes one argument $x, is created first. Then, it is called using a variable $cube as a reference to the func- tion: $cube(3). Pointy blocks are quite handy in loops. for 1..10 +> $c { say $c; } The for loop takes two arguments: the range 1..10 and the block of code with the argument $c. The whole construction looks like syntactic sugar for loops. There can be more than one argument. In that case, list them all after an arrow. my $pow = +> $x, $p {$x $p}; say $pow(2, 15); # 32768

The same works with loops and with other Perl elements where you need passing anonymous code blocks. for 0..9 +> $i, $j { say $i + $j; }

In a loop iteration, two values from the list are consumed each time. So, the loop iterates five times and prints the sum of the pairs of num- bers: 1, 5, 9, 13 and 17. 68

Placeholders When an anonymous code block is created, declaring a list of arguments is not mandatory even when a block takes an argument. To let this hap- pen, Raku uses special variable containers, which come with the ^ twigil. This is similar to the predefined variables $a and $b in Perl 5. In the case of more than one argument, their actual order corresponds to the alphabetical order of the names of the ^-ed variables. my $pow = {$^x ** $^y}; say $pow(3, 4); # 81 The values 3 and 4, which were passed in the function call, will land in its variables $^x and $^y, respectively. Now, let us go back to the loop example from the previous section and rewrite it in the form with no arguments (and thus, no arrow). for 0..9 { say "$^n2, $^n1"; }

Note that the code block starts immediately after the list, and there is no arrow. There are two loop variables, $^n1 and $^n2, and they are not in alphabetical order in the code. Still, they get the values as though they were mentioned in the function signature as ($n1, $n2). Finally, the placeholders may be named parameters. The difference is in the twigil. To make the placeholder named, use the colon :. my $pow = {$:base ** $:exp}; say $pow(:base(25), :exp(2)); # 625

With the named placeholders, the alphabetical order is of no im- portance anymore. The following call gives us the same result.

69

say $pow(:exp(2), :base(25)); # 625 Keep in mind that using named placeholders is sub f($a) { # say $^a; # Error: Redeclaration of symbol '$^a' # as a placeholder parameter } Neither you can use any other placeholder names if the signature of the sub is already defined: sub f($a) { say $^b; # Placeholder variable '$^b' cannot # override existing signature } Function overloading The multi keyword allows defining more than one function (or sub- routine, or simply sub) with the same name. The only restriction is that those functions should have different signatures. In Raku, the signature of the sub is defined together with its name, and the arguments may be typed. In the case of multi subs, typed arguments make even more sense because they help to distinguish between different versions of the function with a single name and make a correct choice when the com- piler needs to call one of them. multi sub twice(Int $x) { return $x * 2; } multi sub twice(Str $s) { return "$s, $s"; } 70 specifying a signature to the block, and you cannot have both. just a different way of The following example demonstrates that you cannot use a placeholder with the name of the already existing parameter:

say twice(42); # 84 say twice("hi"); # hi, hi As we have two functions here, one taking an integer argument and another expecting a string, the compiler can easily decide which one it should use. Sub overloading with subtypes Multi subs can be made even more specific by using subtypes. In Raku, subtypes are created with the subset keyword. A subtype definition takes one of the existing types and adds a restriction to select the val- ues to be included in the subtype range. The following lines give a clear view of how subtypes are defined. From the same integer type, Int, the Odd subtype selects only the odd num- bers, while the Even subtype picks only the even numbers. subset Odd of Int where {$^n % 2 == 1}; subset Even of Int where {$^n % 2 == 0}; Now, the subtypes can be used in the signatures of the multi subs. The testnum function has two versions, one for odd and one for even num- bers. multi sub testnum(Odd $x) { say "$x is odd"; } multi sub testnum(Even $x) { say "$x is even"; }

Which function will be used in a call, testnum($x), depends on the actual value of the variable $x. Here is an example with the loop, calling either testnum(Even) for even numbers or testnum(Odd) for odd numbers.

71

for 1..4 +> $x { testnum($x); }

The loop prints a sequence of alternating function call results, which tells us that Raku made a correct choice by using the rules provided in the subtype definitions. 1&is&odd&& 2&is&even&& 3&is&odd&& 4&is&even& Modules Basically, the Raku modules are the files on disk containing the Raku code. Modules are kept in files with the .pm extension. The disk hierar- chy reflects the namespace enclosure, which means that a module named X::Y corresponds to the file X/Y.pm, which will be searched for in one of the predefined catalogues or in the location specified by the + I command line option. Raku has more sophisticated rules for where and how to search for the real files (e. g., it can distinguish between different versions of the same module), but let us skip that for now. module The keyword module declares a module. The name of the module is given after the keyword. There are two methods of scoping the module. Either it can be a bare directive in the beginning of a file, or the whole module can be scoped in the code block within the pair of braces. In the first option, the rest of the file is the module definition (note the presence of the unit keyword).

72

unit module X; sub x() { say "X::x()"; }

In the second option, the code looks similar to the way you declare classes (more on classes in Chapter 4). module X { sub x() { say "X::x()"; } } export The my and our variables, as well as subs, which are defined in the module, are not visible outside of its scope by default. To export a name, the is export trait is required. unit module X; sub x() is export { say "X::x()"; }

This is all you need to do to be able to call the x() sub in the pro- gramme using your module. use To use a module in your code, use the keyword use. An example. Let us first create the module Greet and save it in the file named Greet.pm.

73

unit module Greet; sub hey($name) is export { say "Hey, $name "; } Then, let us use this module in our programme by saying use Greet. use Greet;

hey("you"); # Hey, you

Module names can be more complicated. With is export, all the ex- ported names will be available in the current scope after the module is used. In the following example, the module Greet::Polite sits in the Greet/Polite.pm file. module Greet::Polite { sub hello($name) is export { say "Hello, $name "; } } The programme uses both of these modules and can access all the ex- ported subs. use Greet; use Greet::Polite;

hey("you"); # a sub from Greet hello("Mr. X"); # from Greet::Polite import The use keyword automatically imports the names from modules. When a module is defined in the current file in the lexical scope (please note that the module can be declared as local with my module), no im- 74

port will be done by default. In this case, importing the names should be done explicitly with the import keyword. my module M { sub f($x) is export { return $x; } }

import M;

say f(42);

The f name will only be available for use after it is imported. Again, only the names marked as is export are exported. As import happens in the compile-time, the import instruction itself can be located even after some names from the module are used. my module M { sub f($x) is export { return $x; } }

say f(1); # 1 import M; say f(2); # 2 need To just load a module and do no exports, use the need keyword. Let us create a module named N, which contains the sub n(). This time, the sub is declared as our but with no is export. unit module N;

our sub n() { say "N::n()"; }

75

Then you need a module and may use its methods using the fully quali- fied names. need N;

N::n();

The sequence of the two instructions: need M; import M; (now im+ port should always come after the need) is equivalent to a single use M; statement. require The require keyword loads a module at a runtime unlike the use, which loads it at the compile-time. For example, here is a module with a single sub, which returns the sum of its arguments. unit module Math; our sub sum(*@a) { return [+] @a; }

(The star in *@a is required to tell Perl to pack all the arguments into a single array so that we can call the sub as sum(1, 2, 3). With no *, a syntax error will occur, as the sub expects an array but not three sca- lars.) Now, require the module and use its sub. require Math;

say Math::sum(24..42); # 627 Before the import Math instruction, the programme will not be able to call Math::sum() because the name is not yet known. A single import 76

Math; will not help as the import happens at compile-time when the module is not loaded yet. Import summary Here is a concise list of the keywords for working with modules. use loads and imports a module at compile time need loads a module at compile time but does not import anything from it import imports the names from the loaded module at compile time require loads a module at runtime without importing the names

We have already seen elements of the object-oriented programming in Raku. Methods may be called on those variables, which do not look like real objects from the first view. Even more, methods may be called on constants. The types that were used earlier (like Int or Str) are container types. Variables of a container type can contain values corresponding to some native representation. The compiler does all the conversion it needs for executing a programme. For example, when it sees 42.say, it calls the say method, which the Int object inherits from the top of the type hierarchy in Raku. Raku also supports object-oriented programming in its general under- standing. If you are familiar with how to use classes in other modern programming languages, it will be easy for you to work with classes in Raku. This is how the class is declared:

Class attributes Class data variables are called attributes. They are declared with the has keyword. An attribute’s scope is defined via its twigil. As usual, the first character of the twigil indicates the type of the container (thus, a scalar, an array, or a hash). The second character is either . if a variable is public or for the private ones. An accessor will be generated by a compiler for the public attributes.

To create or instantiate an object of the class X, the constructor is called: X.new(). This is basically a method derived from the Any class (this is one of the classes on the top of the object system in Raku).

At this point, you can read public attributes.

Reading from $.name is possible because, by default, all public fields are readable and a corresponding access method for them is created. However, that does not allow changing the attribute. To make a field writable, indicate it explicitly by adding the is rw trait.

Now, read and write actions are available. $cafe.name = "Berlin"; say $cafe.name; Class methods The method keyword defines a method sub routines with

, similarly to how we define sub- . A method has access to all attributes of the class, both public and private.

The method itself can be private. We will return to this later after talk- ing about inheritance. In the following short example, two methods are created, and each of them manipulates the private @ orders array.

The code should be quite readable for people familiar with OOP. Just keep in mind that “everything is an object” and you may chain method calls.

Instance methods receive a special variable, self (having no sigil), which points to the current object. It can be used to access instance data or the class methods.

Inheritance

Inheritance is easy. Just say is Baseclass when declaring a class. Hav- ing said that, your class will be derived from the base class.

The further usage of the inherited classes is straightforward.

It is important that the result of the method search does not depend on which type was used to declare a variable. Raku always will first use the methods belonging to the class of the variable, which is currently stored in the variable container. For example, return to the previous example and declare the variable $b to be one of type A, but still create an instance of B with B.new. Even in that case, calling $b.x will still lead to the method defined in the derived class. my A $b = B.new; $b.x; # B.x $b.y; # A.y Meta-methods (which also are available for every object without writ- ing any code) provide information about the class details. In particular, to see the exact order in which method resolution will be executed, call the .^mro metamethod. say $b.^mro; In our example, the following order will be printed. B)&(A)&(Any)&(Mu& Of course, you may call the .^mro method on any other variable or ob- ject in a programme, regardless of whether it is an instance of the user- defined class, a simple variable, or a constant. Just get an idea of how this is implemented internally. $ raku +e'42.^mro.say' Int)&(Cool)&(Any)&(Mu& 84

Multiple inheritance When more than one class is mentioned in the list of base classes, we have multiple inheritance.

With multiple inheritance, method resolution order is more important, as different base classes may have methods with the same name, or, for example, the two base classes have another common parent. This is why you should know the order of the base class now.

Here, the method named meth exists in both parent classes A and B, thus calling it on variables of the types C and D will be resolved differ- ently. my $c = C.new; $c.meth; # A.meth

my $d = D.new; $d.meth; # B.meth This behaviour is confirmed by the method resolution order list, which is actually used by the compiler.

Private (closed) methods Now, after we have discussed inheritance, let us return to the private (or closed) methods. These methods may only be used within the class itself. Thus, you cannot call them from the programme that uses an instance of the class. Nor are they accessible in the derived classes. An exclamation mark is used to denote a private method. The following example demonstrates the usage of a private method of a class. The comments in the code will help you to understand how it works.

The exclamation mark is actually part of the method name. So you can have both method meth and method meth in the same class. To access them, use self.meth and self meth, respectively:

Submethods

Raku defines the so-called submethods for classes. These are the methods which are not propagating to the subclass’s definition. The submethods may be either private or public, but they will not be inher- ited by the children.

Constructors You may have noticed in the previous examples that two different ap- proaches to creating a typed variable were used. The first was via an explicit call of the new constructor. In this case, a new instance was created.

In the second, a variable was declared as a typed variable. Here, a con- tainer was created.

Creating a container means not only that the variable will be allowed to host an object of that class but also that you will still need to create that object itself.

Let us consider an example of a class which involves one public method and one public data field.

The internal public variable $.x is initialized with the constant value. Now, let us create a scalar container for the variable of the A class. my A $a; The container is here, and we know its type, but there are no data yet. At this moment, the class method may be called. It will work, as it is a class method and does not require any instance with real data.

Meanwhile, the $.x field is not available yet.

We need to create an instance object by calling a constructor first.

Please note that the initialization (= 42) only happens when a construc- tor is called. Prior to this, there is no object, and thus no value can be assigned to an attribute. The new method is inherited from the Mu class. It accepts a list of the named arguments. So, this method can be used on any object with any reasonable arguments. For instance:

Note that the name of the field (x) may not be quoted. An attempt of A.new('x' ⇒ 14) will fail because it will be interpreted as a Pair being passed as a positional parameter. Alternatively, you can use the :named(value) format for specifying named parameters:

For the more sophisticated constructors, the class’s own BUILD sub- method may be defined. This method expects to get a list of the named arguments.

This programme prints the following output:

Roles Apart from the bare classes, the Raku language allows roles. These are what are sometimes called interfaces in other object-oriented languages. Both the methods and the data, which are defined in a role, are availa- ble for “addition” (or mixing-in) to a new class with the help of the does keyword. A role looks like a base class that appends its methods and data to gen- erate a new type. The difference between prepending a role and deriv- ing a class from a base class is that with a role, you do not create any inheritance. Instead, all the fields from the role become the fields of an existing class. In other words, classes are the is a characteristic of an object, while roles are the does traits. With roles, name conflicts will be found at compile time; there is no need to traverse the method resolu- tion order paths. The following example defines a role, which is later used to create two classes; we could achieve the same with bare inheritance, though:

Let us try that in action. First, the cafe.

my $cafe = Cafe.new; $cafe.order(10); $cafe.order(20); say $cafe.bill; # Immediate 33 Then, the restaurant. (Note that this code will have a delay because of the class definition). my $restaurant = Restaurant.new; $restaurant.order(100); $restaurant.order(200); say $restaurant.bill; # 390 after some unpredictable delay Roles can be used for defining and API and forcing the presence of a meth- od in a class that uses a role. For example, let’s create a role named Liq+ uid, which requires that the flows method must be implemented.

It is not possible to run this programme as it generates a compile-time error:

Note that the ellipsis …​ is a valid Raku construction that is used to create forward declarations.

Channels Raku includes a number of solutions for parallel and concurrent calcu- lations. The great thing is that this is already built-in into the language and no external libraries are required. The idea of the channels is simple. You create a channel through which you can read and write. It is a kind of a pipe that can also easily transfer Raku objects. If you are familiar with channels in, for example, Go, you would find Raku’s channels easily to understand. Read and write In Raku, there is a predefined class Channel, which includes, among the others, the send and the receive methods. Here is the simplest example, where an integer number first is being sent to the channel $c and is then immediately read from it.

A channel can be passed to a sub as any other variable. Should you do that, you will be able to read from that channel in the sub.

It is possible to send more than one value to a channel. Of course, you can later read them all one by one in the same order as they were sent.

In the last example, instead of the previously used receive method, another one is used: $channel.poll. The difference lies in how they handle the end of the queue. When there are no more data in the chan- nel, the receive will block the execution of the programme until new data arrive. Instead, the poll method returns Nil when no data are left. To prevent the programme from hanging after the channel data is con- sumed, close the channel by calling the close method.

Now, you only read data, which are already in the channel, but after the queue is over, an exception will occur: Cannot receive a mes+ sage on a closed channel. Thus either put a try block around it or use poll.

Here, closing a channel is a required to quit after the last data piece from the channel arrives. The list method The list method accompanies the previously seen methods and re- turns everything that is left unread in the channel.

The method blocks the programme until the channel is open, thus it is wise to close it before calling the list method. Beyond scalars Channels may also transfer both arrays and hashes and do it as easily as they work with scalars. Unlike Perl 5, an array will not be unfolded to a list of scalars but will be passed as a single unit. Thus, you may write the following code.

The @a array is sent to the channel as a whole and later is consumed as a whole with a single receive call. What’s more, if you save the received value into a scalar variable, that variable will contain an array.

The same discussions apply to hashes.

Instead of calling the list method, you can use the channel in the list context (but do not forget to close it first).

Note that if you send a list, you will receive it as a list element of the @v array. Here is another example of “dereferencing” a channel:

The closed method The Channel class also defines a method that checks on whether the channel is closed. This method is called closed.

Despite the simplicity of using the method, it in fact returns not a sim- ple Boolean value but a promise object (a variable of the Promise class). A promise (we will talk about this later) can be either kept or broken. Thus, if the channel is open, the closed promise is not yet kept; it is only given (or planned).

After the channel is closed, the promise is kept.

You can see the state of the promise above in its status field.

In this section, we discussed the simplest applications of channels, where things happen in the same thread. The big thing about channels is that they transparently do the right thing if you’re sending in one or more threads, and receiving in another one or more threads. No value will be received by more than one thread, and no value shall be lost because of race conditions when sending them from more than one thread.

Promises Promises are objects aimed to help synchronize parallel processes. The simplest use case involving them is to notify if the earlier given promise is kept or broken or if its status is not yet known. Basics The Promise.new constructor builds a new promise. The status of it can be read using the status method. Before any other actions are done with the promise, its status remains to be Planned.

When the promise is kept, call the keep method to update the status to the value of Kept.

Alternatively, to break the promise, call the break method and set the status of the promise to Broken.

Instead of asking for a status, the whole promise object can be convert- ed to a Boolean value. There is the Bool method for that; alternatively, the unary operator ? can be used instead.

Keep in mind that as a Boolean value can only take one of the two pos- sible states, the result of the Boolean typecast is not a full replacement for the status method. There is another method for getting a result called result. It returns truth if the promise has been kept.

Be careful. If the promise is not kept at the moment the result is called, the programme will be blocked until the promise is not in the Planned status anymore. In the case of the broken promise, the call of result throws an excep- tion.

Run this programme and get the exception details in the console. Tried&to&get&the&result&of&a&broken&Promise& To avoid quitting the programme under an exception, surround the code with the try block (but be ready to lose the result of say—it will not appear on the screen).

The cause method, when called instead of the result, will explain the details for the broken promise. The method cannot be called on the kept promise:

Like with exceptions, both kept and broken promises can be attributed to a message or an object. In this case, the result will return that mes- sage instead of a bare True or False. This is how a message is passed for the kept promise:

This is how it works with the broken promise:

Factory methods There are a few factory methods defined in the Promise class. start The start method creates a promise containing a block of code. There is an alternative way to create a promise by calling Promise.start via the start keyword.

(Note that in Raku, a semicolon is assumed after a closing brace at the end of a line.)

The start method returns a promise. It will be broken if the code block throws an exception. If there are no exceptions, the promise will be kept.

Please note that the start instruction itself just creates a promise and the code from the code block will be executed on its own. The start method immediately returns, and the code block runs in parallel. A test of the promise status will depend on whether the code has been exe- cuted or not. Again, remember that result will block the execution until the promise is not in the Planned status anymore. In the given example, the result method returns the value calculated in the code block. After that, the status call will print Kept. If you change the last two lines in the example, the result may be dif- ferent. To make the test more robust, add a delay within the code block.

Now, it can be clearly seen that the first call of $p.status is happening immediately after the promise has been created and informs us that the promise is Planned. Later, after the result unblocked the programme flow in about a second, the second call of $p.status prints Kept, which means that the execution of the code block is completed and no excep- tions were thrown. 104

Would the code block generate an exception, the promise becomes broken.

The second thing you have to know when working with start is to un- derstand what exactly causes an exception. For example, an attempt to divide by zero will only throw an exception when you try using the re- sult of that division. The division itself is harmless. In Raku, this be- haviour is called soft failure. Before the result is actually used, Raku assumes that the result is of the Rat (rational) type.

in and at The other two factory methods, Promise.in and Promise.at, create a promise, which will be kept after a given number of seconds or by a given time. For example:

The programme prints the following lines. Planned Planned Planned Kept Kept

That means that the promise was kept after three seconds. anyof and allof Another pair of factory methods, Promise.anyof and Promise.allof, creates new promises, which will be only kept when at least one of the promises (in the case of anyof) is kept or, in the case of allof, all of the promises listed at the moment of creation are kept. One of the useful examples found in the documentation is a timeout keeper to prevent long calculations from hanging the programme. Create the promise $timeout, which must be kept after a few seconds, and the code block, which will be running for longer time. Then, list them both in the constructor of Promise.anyof.

The code should be terminated after three seconds. At this moment, the $timeout promise is kept, and that makes the $done promise be kept, too.

then The then method, when called on an already existing promise, creates another promise, whose code will be called after the “parent” promise is either kept or broken.

The code above produces the following output:

promised OK done

In another example, the promise is broken.

The only output here is the following: oops

An example Finally, a funny example of how promises can be used for implement- ing the sleep sort algorithm. In sleep sort, every integer number, con- sumed from the input, creates a delay proportional to its value. As the sleep is over, the number is printed out. Promises are exactly the things that will execute the code and tell the result after they are done. Here, a list of promises is created, and then the programme waits until all of them are done (this time, we do it using the await keyword).

Provide the programme with a list of integers:

For each value, a separate promise will be created with a respective delay in seconds. You may experiment and make smaller delays such as sleep $a / 10 instead. The presence of await ensures that the pro- gramme is not finished until all the promises are kept. As an exercise, let’s simplify the code and get rid of an explicit array that collects the promises.

First, we use the $_ variable here and thus don’t have to declare $a. Second, notice the do for combination, which returns the result of each loop iteration. The following code will help you to understand how that works:

Grammar 应用的第一个例子是定义赋值操作并包含打印指令的小语言的 grammar。以下是此语言的程序示例。

让我们开始编写该语言的 grammar。 首先，我们必须表达一个事实，即程序是由分号分隔的一系列语句。 因此，在顶层语法看起来像这样：

在这里，Lang 是 grammar 的名称，而 TOP 是解析将开始的起始规则。规则的内容是由一对符号 ^ 和 $ 包围的正则表达式，用于将规则绑定到文本的开头和结尾。换句话说，整个程序应该匹配 TOP 规则。规则的核心部分 <statements> 引用了另一条规则。规则将忽略其各部分之间的所有空格。因此，你可以自由地在 grammar 的定义中添加空格，以使其易于阅读。

第二条规则解释了 <statements> 的含义。<statements> 块是一系列单独的 statement。它应该包含至少一个 statement，如 + 量词所要求的那样，并且分隔符是分号。在 %% 符号后面是分隔符。在 grammar 中，这意味着指令之间必须有分隔符，但是你可以在最后一个之后省略分隔符。如果只有一个百分号字符而不是两个百分号字符，则规则也要求在最后一个语句之后有分隔符。

下一步是描述 statement。目前，我们的语言只有两个操作：赋值和打印。它们中的每一个都接受值或变量名。

垂直条分隔备选分支，就像它在 Perl 5 中的正则表达式一样。为了使代码看起来更好看并简化维护，可以在第一个子规则之前添加额外的垂直条。 以下两个描述相同：

然后，让我们定义 assignment 和 printout 的含义。

在这里，我们看到字符串字面量，即 '=' 和 'print'。 同样，它们周围的空格不会影响规则。

expression 与标识符（在我们的例子中是变量名）或常量值匹配。 因此，expression 是 identifier 或没有附加字符串的 value。

此时，我们应该编写标识符和值的规则。 对于那种 grammar，最好使用另一种名为 token 的方法。 在 token 中，空格很重要（那些与大括号相邻的空格除外）。

标识符是一组字母：

这里，<:alpha> 是包含所有字母字符的预定义字符类。

我们示例中的值是一组数字，因此我们这里仅限于整数。

我们的第一个 grammar 已经完成。 现在可以使用它来解析文本文件。

如果文件内容已经存储在变量中, 那么你可以使用 Lang.parse($str) 方法来解析它。(附录中有更多关于从文件中读取的内容)

如果解析成功, 即如果文件包含有效的文法, 那么 $parse 变量会包含一个 Match 类型的对象。可以把它转储出来(say $parsed)并看看里面是什么。

此输出对应于本节开头的示例程序。 它包含已解析程序的结构。 捕获的部分显示在括号 ｢…​｣ 中。 首先，打印整个匹配的文本。 实际上，由于 TOP 规则使用了一对 ^ …​ $ 结构，因此整个文本应该与规则匹配。

然后，打印解析树。 它从 <statements> 开始，然后 grammar 的其他部分完全按照文件中的程序包含的内容呈现。 在下一级别，你可以看到 identifier 和 value token 的内容。

如果程序在文法上不正确，则该解析方法将返回空值(Any)。 如果只有程序的起始部分与规则匹配，则会发生同样的情况。

为方便起见，这是完整的 grammar：

到目前为止，grammar 看到了程序的结构，并且可以判断它是否在 grammar 上是正确的，但它不会执行程序中包含的任何指令。 在本节中，我们将扩展解析器，以便它可以实际执行程序。

我们的示例语言使用变量和整数值。值是常量并描述自己。对于变量，我们需要创建一个存储。在最简单的情况下，所有变量都是全局变量，并且需要一个散列：my %var;。

我们现在要实现的第一个 action 是赋值。 它将获取值并将其保存在变量存储中。 在 grammar 的 assignment rule 中，期望在等号的右侧是一个 expression。 表达式可以是变量也可以是数字。为了简化变量名查找，让我们使 grammar 更复杂一些，并将赋值和打印规则分别拆分为两个备选项。