Raku 单行程序

我们来谈谈 Rakudo^[1] 编译器为我们提供的命令行选项。

让我们通过几个单行程序，把文件作为开胃菜来工作。下一整章的内容都是关于文件的工作。

$*ARGFILES 是一个内置的动态变量，在处理多个输入文件时可能会很方便。

如何读取命令行中传递的两个或多个文件？

如果你需要把所有的文件一起处理，就好像它们是一个数据源一样，你可以用一个单行程序要求变量来完成这项工作:

在程序内部，你不必考虑循环处理文件，$*ARGFILES 会自动帮你完成。

如果命令行中没有文件，变量将被附加到 STDIN 上:

确实很方便，不是吗？

让我们来解决一个任务，重命名所有在命令行参数中传递的文件，并以首选的格式给文件顺序号。下面是一个命令行的例子:

在本例中，当前目录下的所有图像文件将被重命名为 img_0001.jpg、img_0002.jpg 等。

这里是 Raku 中可能的解决方案(保存在 rename.raku 文件中):

预先定义的动态变量 @ARGS 包含命令行的参数。在上面的例子中，shell 将 .jpg 掩码展开为一个文件列表，所以数组包含了所有文件。最后一个元素是重命名样本 img_0000.jpg。

如果你熟悉 C 或 Perl，请注意这个变量叫做 ARGS，而不是 ARGV。

为了循环处理所有的文件（并跳过最后一个带有文件掩码的文件项），我们取 @ARGS 的片断。0..-2 构造创建一个索引范围，以取除最后一个元素以外的所有元素。

然后对列表进行排序(原 @*ARGS 数组保持不变），我们使用 map 方法对文件名进行迭代。

map 的主体包含一个 WhateveCode 块(见第6章)；它接收当前值的字符串表示，将其制作成一个 IO::Path 对象，然后调用 rename 方法。注意，IO 方法创建了一个 IO::Path 类的对象；而裸露的 IO 则是 Raku 对象系统层次结构中的一个角色。

最后，增量运算符 ++ 会改变重命名样本（该样本保存在 @ARGS 的最后一个，-1 号元素中）。当运算符应用于一个字符串时，它会递增其中的数字部分，所以我们得到 img_0001.jpg、img_0002.jpg 等。

让我们把几个文件合并成一个文件。我们的任务是将两个（或三个，或更多）文件逐行复制其内容。例如，我们要合并两个日志文件，知道它们的所有行都是对应的。

文件 a.txt:

文件 b.txt:

第一个单行程序就说明了这个问题:

假设程序的运行方式如下:

对于命令行中的每一个文件名(@*.ARGS.map)，都会创建一个 IO::Path 对象(.IO)，然后读取文件中的行(.lines)。

在有两个文件的情况下，我们有两个序列，然后使用 zip 元操作符 Z 应用于连接后缀 ~ 逐行连接。

在这一步之后，我们得到另一个序列，我们可以逐行打印(.say for)。

结果形式上是正确的，但我们要在原来的行间加一个空格。下面是单行程序的更新版本:

在这里，每一行的末尾都会附加一个空格字符(.map: *~ ' ')，由于合并后的行末尾会有一个额外的空格，所以会被 trim 方法去除。它的同级，trim-trailing，可以用来代替（如果你关心原来的尾部空格恰好在第二个文件中，也可以用一个 regex）。

经过以上的修改，现在两个文件已经完美的合并了:

例如，将同一个文件合并到自己身上，或者提供两个以上的文件，都没有问题:

在本节中，我们将创建一个单行程序，以相反的顺序打印文本文件的行(就像 tail -r 那样）。

第一个单行程序可以完成 STDIN 流的工作。

运行该程序为:

在这种情况下，$*IN 可以省略，这使得单行本更短:

如果你想直接从 Raku 读取文件，修改一下程序，用命令行参数创建一个文件句柄:

现在你运行它如下:

重要的是要记住，line 方法的默认行为是将换行符从最终的行序列中排除（该方法返回一个 Seq 对象，而不是数组或列表）。

在 Raku 中，lines 方法根据 IO::Handle 对象的 .nl-in 属性中存储的值来分割行。

你可以用下面的小脚本查看当前的行分隔符的值。

这就是你在那里发现的默认情况。

有趣的是，你可以控制行的行为，并告诉 Raku 不要排除换行字符。

chomp 属性默认设置为 True。你也可以更改默认的分隔符。

请注意，如果不使用 chomping，就不需要在行上显式的 for 循环：在最后两个单行中，.put 方法是直接在序列对象上调用的。在早期的版本中，字符串不包含新行字符，因此它们会被打印成一个长行。

给你一个小作业。告诉大家 put 和 `say 的区别。

任务是找出 3 和 5 在 1000 以下的所有倍数之和。我们感兴趣的行的第一个元素是 3，5，9，15，20，21 等。大家已经可以看到，其中有些元素，如15，既是 3 的倍数，又是 5 的倍数，所以不能把 3 和 5 的倍数分别相加。

小故事就在这里。

现在，我们来解读一下。

我们需要的是过滤那些 3 或 5 的倍数的数字。如果你重新阅读上一句话，你应该会有一个钟声：在 Raku 中，这可以通过 junctions 来实现，非正式地称为量子叠加。要测试一个数字是否可以被 3 或 5 整除，请写出以下内容。

对了，%% 这个整除操作符，是个很贴心的东西，有助于避免布尔测试中的否定式，你如果只有一个 %，会不会写成这样。

好了，主要条件已经准备好了，我们来扫描1到(含)999之间的数字。

这里出现了一些比较有趣的语言元素。例如，WhateverCode 块，它是由一个 字符引入的（见第6章）。与方法调用的冒号形式一起，它允许摆脱一对嵌套的括号和小括号。如果没有 ，代码会更加复杂。

数字已经被过滤(如果你喜欢的话，可以用 grepped)，现在是时候把它们加起来并打印出结果了。我们来到本节开头的最后一个单行程序。

当然，与其写 say sum(…​)，还不如写一两个方法调用。

作为奖励曲目，这是我的第一个解决方案，它比单行程序要长得多。

你可能会问，这有什么大不了的，调用一种 rand 函数不是一个常规任务吗？嗯，从某种意义上说，是的，但你可能更喜欢调用一个方法。

让我们看看下面的代码:

这就是整个程序，它生成的是 2020 以下的随机数。它只使用方法调用，一个接一个地链起来。如果你从来没有见过 Raku，你首先注意到的是这里有一个对数字进行调用的方法。这在这个语言中并不是什么特别的东西。

在一个数字上调用 rand 方法，有可能是对 Cool 类中定义的方法的调用，而 Cool 类会立即委派给数字的数字代表。

在 Num 类的后面，发生了对底层 NQP 引擎的调用。

在我们的例子中，对象 2020 是一个 Int，所以 rand 被直接派发到 Num 类的方法上。

rand 方法返回的是一个浮点数，所以调用另一个方法 Int 来得到一个整数。

运行代码几次，确认它能生成随机数。

如果你想了解随机数生成器的质量，可以深入到 NQP 和 MoarVM，之后再深入到虚拟机的后端引擎。为了使结果可重复（例如，用于测试），通过调用 srand 函数设置种子。

请注意，srand 例程是一个子程序，而不是一个方法。它也被定义在同一个 Num 类中。

如果你有机会看到源文件，你很可能会注意到，还有一个独立的 rand 子程序。

你只能在没有参数的情况下调用它，在这种情况下，Raku 会生成一个介于 0 和 1 之间的随机数字。如果你传递参数，你会得到一个错误的解释，方法调用是比较好的。

在这一节中，我们将看欧拉工程的第十三个问题。让我展示其中的一部分。

的确，这个数字看起来很大，任务是找到一百个整数之和的前十位，每个整数由50位组成。

听起来像一个任务，可能需要一些优化和简化，以摆脱一切不有助于前十位数的结果。但在 Raku 中不是这样。

在这里，你可以简单地将数字相加，并取其中的前十位数。

Raku 默认使用任意长的整数；你不需要包含任何模块或以其他方式激活这种行为。你甚至可以计算幂数，并很快得到结果。

另一个需要注意的是，我们可以透明地将字符串转换为数字，反之亦然。在当前的程序中，数字列表以一对角括号内的引号字符串列表的形式呈现。

在这个列表中，你调用了和方法，它可以处理数字。得到总和后，你又把它当作一个字符串，并提取其中的前十个字符。整个代码看起来非常自然，而且很容易阅读。

我们的任务是找到最大的回文数（从两端读出的数字，如1551），它是两个三位数的乘积。

换句话说，我们要扫描 999×999 以下的数字，可以优化解法，但实际上，我们只需要允许数字，也就是积，因此，我们不要跳过乘法部分。

这是我们的单行程序。

大家已经准备好了，链式方法调用在 Raku 单行程序中使用是非常方便的。

前面我们也看到了方法调用的冒号形式，但这次我们使用的是一个带有占位变量的代码块。这里不太清楚是否可以使用星号，因为我们在代码块中需要变量两次。

这一行的第一部分使用了交叉运算符 X*，（参见第 6 章）。它生成了所有三位数的乘积。由于我们需要最大的数字，所以从右到左开始是合理的，这就是为什么序列是 999…​100，而不是 100…​999。

我们来看看 grepped 乘积序列中的前几个数字。

单行程序并不总是很理想。在我们的例子中，我们需要生成整个产品序列，以找到其中的最大值。答案位于第三位，所以用 first 取代 max 将是一个错误。但好在如果你使用第一，Raku 将不会生成所有的数字。还有一个有用的方法，head，也可以防止生成超过必要的数量。

下面的代码运行得更快，并且给出了正确的结果。

这里的任务是找出所有低于400万的斐波那契偶数之和。

这就是完整的解决方案。

从左端或右端解析代码同样有趣。让我们从左端开始。

在第一个括号内，我们正在生成一个斐波那契数列，这个数列从两个1开始，接下来生成的每个数都是前两个数的和。你可以用一个WhateverCode块来表达它。* + * 等同于 {$^a + $^b}。

序列的一个不太为人所知的特征是最后的条件。在许多例子中，你会看到一个裸星或一个 Inf。在我们的例子中，我们用一个明确的上边界来限制序列。

请注意，你不能简单地写出：

为了更好地可视化，可以尝试一个更小的限制，比如100。

当序列越过我们想要的边界时，生成不会停止。只有当序列的下一个计算元素正好等于给定的数字时，它才会停止生成，例如。

如果你不知道 400 万前面的斐波那契数，请使用另一个带有布尔条件的 WhateverCode 块。* >= 4_000_000。请注意，这个条件和你在常规循环中写的条件是相反的，因为这里我们要求的是超过四百万，而不是小于。当你不得不停止序列时，这个条件就变成了 True。如果没有星号，你可以使用默认变量: {$_ >= 4_000_000}。

代码的其余部分则是对偶数进行抓取，并将它们相加。

是的，很有可能，你从来没有在实际的代码中使用过这样的数字，同样，很有可能，你用它们解决了很多教育问题。尽管如此，今天，让我们尝试着去接近 Code-Golf.io 网站上的斐波那契问题的最短解法（另见第7章关于高尔夫编码的内容）。

我们如何形成一个斐波那契序列？用序列运算符 …​:

如果你想在代码中加入一些异国情调，你可以用 Inf 或 ∞ 代替最后一颗星。在任何情况下，结果都是一个 Seq 类型的懒惰序列。Raku 不会立即计算它（也不能，因为右边缘是无限的）。

最后，让我们找到第一个斐波那契数的索引，它有 1000 位。当然，你可以在上面创建的序列上循环，自己追踪指数。但是在 Raku 中，有一个选项可以修改 grep 例程族，要求它返回匹配项的索引而不是项本身。

另外，我们不使用 grep，而是使用一个更合适的方法，首先。如果我们调用k键的方法，它将返回第一个匹配的项目或其索引。只要提到键就够了，其实不需要值。

这个程序打印一个整数，这就是给定问题的正确答案。

这里有一个插图来帮助制定任务。我们的目标是找到A和B两点之间的距离。

为了使答案更透明，更容易检查，我选择了线段AB，使它是边长为3和4的直角三角形的斜边。在这种情况下，第三条边的长度是5。

下面是解题思路。

这段代码使用的是复数，只要把问题移到复数平面上，你就会从表面上两点之间的距离等于这两个数相减的绝对值中获得收益。

在这种情况下，其中一个点是复平面上的5.5+2i点，第二个点是1.5+5i。在乐乐中，你写下复数就像写数学一样。

如果没有复数的内置支持，你就必须明确使用毕达哥拉斯定理。

作业。修改 Raku 的 grammar，允许使用以下代码。

让我们来解决这个问题，你需要打印第10001个质数（第一个是2）。

Raku 编程语言在质数方面很擅长，因为它有一个 Int 类的内置方法 is-prime。

有几种生成质数的方法。对于单行道来说，最好的是最简单，但效率最低的方法，它可以测试每个数字。

计算结果大约需要半分钟，但代码相当短。用所谓的埃拉托斯特尼斯的筛子来解决这个任务，效率要高得多，但可能需要更多的代码行，因此不是单行程序，不在本书的讨论范围之内。

在本节中，我们使用两种不同的方法计算 π 的值。目标是尝试不同的方法来生成数字序列。

准备工作

当然，你不需要自己计算π的值，因为 Raku 语言给我们提供了一些预定义的常量，形状有 π 和 pi 两种，还有双倍值 τ 和 tau。

但是为了演示 map 和 Seq 的用法，我们来实现一个最简单的算法来计算 π。

这里有一个草拟的代码来检查答案。

第一部分

现在，让我们使用 map 来使解更紧凑。最好是让公式也更通用。

这是我们的第一个单行程序。

希望你能理解这里的一切。我们在本书前面的章节中介绍了这个解决方案的不同部分。

但我还是要强调，你需要在-1周围加上括号，如果你键入 -1 $，那么你总是得到-1，因为减号前缀被应用于取幂的结果。所以，正确的代码是 (-1) $。

第二部分

还可以尝试使用序列运算符…​…​根据上面提到的公式生成行，这也很有意思。另外，我们还要用有理数来生成分数 ⅓、⅕ 等。

这个序列以一个有理数 <1/1> 开始，这很方便，因为我们可以立即取其分子和分母。序列的生成器块使用这个数来创建一个新的有理数，它的分母在每次迭代时增加2。

你可能会问我为什么要提到 $n.numerator，它总是1。这是需要的，因为要改变符号，我们需要知道当前值的符号，而符号被保留在有理值的分子部分。

占位符 $^n 自动取生成器代码块的第一个（也是唯一的）数组。

这个序列被生成，直到当前值的绝对值足够小。可能很想用 * ≅ 0 来代替最后的条件，但那个程序会运行太长时间而无法产生结果，因为近似相等运算符的默认容差是 10-15，而行不会那么快收敛。

另外，你也不能使用 < …​ / …​> 语法在生成器中创建一个 Rat。

在这种情况下，Raku 将其视为一种引号结构，如 <red greenblue>，而不是代码块，你会得到一个字符串列表。

第三部分

Damian Conway 提出了以下使用序列的有趣而紧凑的解决方案。

在本节中，我们将看到一个单行程序，它可以计算一个表的列的总和。

下面是一个文件中的一些示例数据。

下面是打印每列三个数字—​总和的代码。

程序会打印出我们需要的数字。

我们知道裸行和 $*IN.lines 是一样的，所以 lines.map 会遍历输入流中的所有行。然后，每一行都会被分割成单词—​由空格分隔的子串。

工作中解析输入数据的部分就完成了。我们已经得到了一些对应于输入数据行的序列。对于我们的示例文件，这些序列如下。

现在，把每个第一个元素、第二个元素等加起来。缩减运算符和拉链元运算符的组合只用四个字符就完成了所有的工作：[Z+]。

这时，我们就有了一个还原序列。

最后一个琐碎的步骤是使用put例程打印数值。如果你做了前面的功课，你就会知道 say 使用 gist 方法（在序列周围加上括号）来可视化结果，而 put 只是简单地使用 Str 方法打印数值。

让我们在脚本中再添加几个字符，以演示如何跳过第一列，例如，包含月份名称。

你只需要做一个切片，选择除第一列以外的所有列。

如你所见，我们甚至不需要自己去数列。1..* 的范围可以使这项工作。

所以，我们的任务是找到所有数字的总和，这些数字等于其数字的阶乘之和。听起来清楚了吗？你可以看一下解题单行程序，以便更好地理解它。

让我们从 …​ 开始。

我们在 3 .. 50_000 的范围内循环。上界是基于一些考虑的猜测。我在这里就不解释了，但如果你好奇的话，可以试着去找答案。基本上，在某些时候你就明白了，这个数字要么是包含了太多的数字，要么就是本身太大了。

第二步是 grep。我们要搜索的数字，是等于($_ ==)和的。它的计算方法是第二次还原加 [+]，但你可以用和的方法代替。

请注意，.comb 是一个调用默认变量 $_ 的方法。梳理方法将数字拆分开来（将它们视为字符）。map 方法将每个数字转换为阶乘(同样，使用还原运算符 [*])。

最后，最外 [+] 将所有 grepped 数字相加，并将结果传递给 say 例程。

虽然本书讲的是单行程序，但在使用之前，单独用一行代码来准备阶乘，会比较实用。

你可能已经看到了得到42的精确值的计算，即生命、宇宙和万物的答案。让我把它复制到这里，利用乐乐的强大和它的任意精密运算，更不用说在代码中直接使用上标的乐趣了。

下面是解决这个问题的完整代码:

运行几次:

我们的代码行每次运行都会生成不同的字符串。如果你还没有安装 Raku，请尝试自己创建一个密码，或者使用上面显示的密码之一。

你也可以问一个问题。密码中会有哪些字符? 很高兴你能问到这个问题! Raku 是一种面向 Unicode 的语言，'0'..'z' 的范围似乎包含了具有不同 Unicode 属性的字符（即，至少是数字和字母）。要想知道里面的内容，只要把我们今天的代码中的 pick 方法去掉就可以了。

这一行打印两个给定字符之间的 ASCII 表子集。

这些是密码中可能出现的字符。选取法可以确保字符不会重复出现。如果使用 roll，则允许字符出现一次以上。

这里的代码使用的是 ASCII 地外的四个字符。

在 Raku 中，你可以在标识符中自由使用 Unicode 字符，例如变量或函数名。但除此之外，还有许多预定义的符号，如 π，它们有 ASCII 的替代符号。检查名为 "Unicode 与 ASCII 符号"的文档页面，以查看可以在 Raku 中使用的 Unicode 字符的全部集合。

只使用 ASCII 码，上面的单行程序可以按以下方式重新编写。

让我们回到上一章的一个帮助程序，看看哪里可以使用 Unicode 字符。

这里有几个机会。

首先，超运算符 <<*>> 可以用适当的法式引号代替。"*"，乘法字符可以用我们已经用过的十字形来代替，"×"。«×». 除法同样可以用："÷"。

其次，序列运算符的三个点可以用一个 Unicode 字符代替：…​（如果你是在 Word 中编程，在输入三次句号后就会自动得到这个字符）。

最后，在最后一行中，一个 Unicode 字符 ∪ 被用来寻找两个集合的交集。这里的字符和你在数学中使用的字符是一样的(你呢?)，但你可以使用它的 ASCII 版本来代替：f(3) (|) f(5)。

在编程语言中，Unicode 的支持是最好的，如果不是最好的话。使用时要注意不要让别人为你的代码而疯狂!

今天，我们就来回答一下今天是什么日子的问题。

所以，要打印答案，可以使用下面一行 Raku 的代码。

它看起来是透明的，并以 YYYY-MM-DD 的格式打印日期。好的部分是 DateTime 类可以直接使用，你不需要导入任何模块。

正如你在前面的章节中已经看到的，链式方法调用在 Raku 中是一种常见的做法。另一种相反的做法是将 say 作为一个子程序，并在方法名后面使用括号。

这段代码也可以用，它是完全正确的，但它看起来很重。

你还应该注意到并告诉你的朋友，在乐道中，你可以在标识符中使用破折号和省略号。

好吧，也许使用省略号并不是一个好主意，但连字符在乐都的源代码中已经被非常广泛地使用了。只要确保在算术表达式中的减号运算符周围加上空格，就可以避免在解析中出现任何冲突。

如果你阅读文档，你会发现另一个以同样方式命名的方法：hh-mm-ss。我打赌你一定明白它的作用。

请注意，对于不同格式的输出，如 dd-mm-yy 或 hh-mm，你不会找到类似的方法。 使用 formatter 代替。它不是一个方法，而是在 Datish 角色中定义的一个属性。在 DateTime 类中有一个默认的 formatter，但你可以通过提供构造函数与你自己的子程序来重新定义它，例如。

这里的 formatter 接收一个匿名的子程序（由一个细小的箭头引入），有一个参数 $dt。

我希望这段代码打印的日期和我们最初的单行程序一样，因为你很可能在一天之内读完了整节内容。

我们接下来的单行程序比较长，最好写成两行，但它会显示出 Raku 的 Date 对象的一个非常好的特点：它可以很容易地在一个范围内使用。

实质上，这个任务是计算 1901年1月1日到 2000年12月31日之间的星期天，并且只计算落在月份第一的星期天。

Raku 中的 Date 对象实现了 succ 和 prec 方法，用于递增和递减日期。也可以使用两个日期作为一个范围的边界。

这里有几个时刻要评论一下。

首先，两个 Date 对象是用一个命名的参数，即年份来创建的。之所以能够做到这一点，是因为构造函数的签名中包含了月份和日期的去错值。

所以，创建1月1日的日期很容易，但是对于一年的最后一天就不能这么做了。但是 Raku 有一个很好的范围运算符 ..^，它可以排除右边的边界，让我们节省不少字符（虽然我们还没有玩 Raku Golf，但这是第7章的主题）。

较长的版本，包括所有明确的日期部分，会像这样。

我们创建了一个范围，并使用一个组合条件来 grep 它的值。请记住，当你想在缺省变量上调用一个方法时，不需要显式地输入 $_。

另一种方法是使用两个带星号的 grep。

你可以在家里做一个练习。打印出今年年底前的剩余天数。

下面是另一个问题的解决方法。任务是算出XX世纪中所有落在每月一号的星期天。

上一次，我们只是在扫描整个世纪的所有日子，选择那些是星期天(.day-of-week == 7)，并且是本月第一天(.day == 1)的日子。

可以做一个更有效的算法。因为我们只对每月的第一天感兴趣，所以没有必要扫描100年的所有36525天。只需要扫描1901年到2000年之间每个月的第一天的1200天就够了。

所以，我们需要两个嵌套循环：过年和过月。我们需要两个 for 吗？不一定。让我们使用X运算符（详见第6章）。

这就是我们的新单行程序。

for 1901…​2000 X 1…​12 循环将XX世纪的每个月都过一遍。对于每个月，我们通过调用一个有三个参数的构造函数来创建一个Date对象。

注意，在循环中，你可以同时使用 $_[0] 和 $_[1]，以及 @_[0] 和 @_[1]。在第一种情况下，$_ 变量包含两个元素的列表，而在第二种情况下，它是一个数组 @_。如果你只是用一个点来调用主题（默认）变量上的方法：.[0] 和 .[1]，则可以实现最短的代码。

你可以键入 Date.new(.[0], .[1], 1) 来代替 Date.new(|@_, 1)。|@_ 语法是用来展开数组的，否则 Raku 会认为你传递的是一个数组作为第一个参数。

所有月份的第一天都会在 gather-take 对的帮助下以一个序列收集。

最后一步是和之前一样的 grep，但这次我们只需要选择太阳日，所以一个 *.day-of-week ==7 的条件就足够了。

elems 方法的调用会返回列表中元素的数量，也就是我们要找的星期天的数量。因此，用 say 打印出来。

根据读者的一个非常贴切的评论，这里有一个更好更简单的解决方法，即使用 + 前缀操作符将一个列表投向其长度。

在前面的章节中，我们经常使用带有交叉操作符的构造。下面是几个例子。

第二行打印1到10的数字的乘法表的项。

关于这样的构造，有一些东西需要学习。

你可能已经注意到 999…​100 和 1..10 之间有两个微妙的区别。在一种情况下，有三个点，在另一种情况下，只有两个点。在第一种情况下，边界是递减的数字，在第二种情况下，边界是递增的。

Raku 中的两个点是范围运算符。它创建一个 Range，或者换句话说，一个 Range 类型的对象。

三个点是序列操作符。在我们的例子中，它创建了一个序列，或者 Seq 类型的对象。

你可以随时通过调用对象上的 WHAT 方法来检查类型（下面是 REPL 会话的一个片段）。

研究一下 Raku 的源代码，看看 Range 和 Seq 有哪些属性，也很有意思。

在 Range 对象中，有最小值和最大值，而在 Seq 中，我们看到的是一个迭代器。

在某些情况下，例如，在一个简单的循环中，你可以选择范围或序列。

但如果你想往下数，范围就不行了。

有了序列，就没有问题了。

在你开始好好感受它们之前，玩玩范围和序列是明智的。将它们保存在变量中，在操作中使用，用 say 或 dd 打印。

作为一个起点，考虑以下三个操作。

我们的下一个客人是一个带有一对方括号的化简结构。当它们不包围一个数组索引时，它们在一个完全不同的领域工作。

在本节中，我们将介绍使用 * 字符的构造。在 Raku 中，你可以根据上下文将其称为星号（或星号，如果你喜欢的话）或任何东西。

Raku 不是一种隐秘的编程语言。在另一方面，有些领域需要花费时间来开始对语法有信心。

让我们来看看 的不同用例，从最简单的开始，争取了解最伤脑筋的，比如 ** *。

前面几个用法很简单，不需要多做评论。

EVAL 例程编译并执行它作为参数得到的代码。

让我们从评估一个简单的程序开始。

这个程序说的是 123，这里就不奇怪了。

不过，也有更复杂的情况。你觉得，下面的程序是怎么打印的？

我想它打印出来的东西和你想象的不一样。

它将大括号之间的内容解析为一个尖锐的块。

如果你试试双引号呢？

现在它甚至拒绝编译。

我们可以通过添加几个神奇的词来修复代码。

这一次，它打印的是 789。

代码的执行（我们还不知道具体时间，这是明天文章的主题），所以你可以进行一些计算，例如。

最后，如果你尝试直接传递一个代码块，即使是盲猴，也无法再次实现目标。

该错误发生在运行时。

这条消息看起来很神秘，但至少我们再次看到，我们得到了一个匿名的尖块传递给函数。

在我们结束之前，尝试使用一个小写的函数名。

在 Raku 中没有这样的功能，我们会得到一个标准的错误信息。

让我们玩高尔夫，打印所有 100 以下的质数。我的解决方案，需要 22 个字符，如下。

在 Raku 中没有更短的解决方案，而在 J 编程语言中，他们只用了 11 个字符。在 Raku 中，方法名已经包含了 8 个字符。我相信，为了赢得所有的高尔夫比赛，你需要一种特殊的语言，它的名字非常短(J就是这样)，并且需要一套内置的例程来生成素数、斐波那契或任何其他数字序列的列表。它还应该大力利用 Unicode 字符空间。

在我们的 Raku 例子中，也有一个 Unicode 字符，.Ⅽ。这不是一个简单的 Ⅽ，即拉丁字母表的第三个字母，而是一个 Unicode 字符 ROMAN NUMERAL ONE HUNDRED(当然，它最初是拉丁字母表的第三个字母)。使用这个符号让我们在解决方案中保存了两个字符。

之所以能够使用 && 技巧，是因为如果第一个操作数为 False，则布尔表达式的第二部分不会被执行。请注意，这里不能使用单个 &。完整的非优化版本的代码将需要额外的空格，看起来像这样。

让我们解决另一个高尔夫任务，并打印前 30 个斐波那契数，一行一个。我们必须在代码中使用尽可能少的字符。

第一种方法比较啰嗦（即使用 ^31 代替 0..30，也需要 33 个字符）。

有一些空间，允许压缩。当然，首先也是最明显的就是去掉空格（剩余28个字符）。

另一个有趣的技巧是使用 >> 元操作符来调用序列中每个元素的 say 方法。它将代码进一步压缩到 24 个字符。

此刻，我们可以采用一些 Unicode，又获得了三个字符（剩下21）。

看起来已经很紧凑了，但还是有一些选项可以尝试。让我们去掉显式切片，并尝试在最后一个元素处停止序列。

代码变长了(23个字符)，但我们不需要一个确切的数字 514 229。给出一些接近的数字就足够了，这个数字比序列的第29个元素大，比第30个元素小。例如，它可以是 823 543，也就是7的幂7，用上标(19个字符)写下来。

最后，可以通过使用另一个代表 80万的 Unicode 字符，让它少一个字符。并不是每一种（如果有的话）字体都能显示一些有视觉吸引力的东西，但乐乐毫无怨言地接受了这个字符。

这18个字符比 code-golf.io 网站的最高结果长了一个字符。我有一种感觉，你可以通过将序列的前两个元素替换为 ^2 来获得另一个字符，但这在当前的 Rakudo 中是行不通的，你必须返回一个字符来扁平化列表。|^2, 这使得解决方案又变成了18个字符.

欲望将条件中的 *> 部分去掉，停止序列，用一个固定的数字代替。不幸的是，没有办法用1和90之间的数字的幂来表达832 040。能不能这样，我们可以用上标来计算这个数字。我们可以用上标来计算这个数字。

另一个想法是使用 regex，但我们在这里至少需要四个字符，这没有帮助。

但我在这里就不说了，让你再想一想。

今天，我们将研究一个计算零的单行本。

如果你熟悉编程，你就会知道，只要你开始使用浮点运算，你就会失去精度，你就会很快面临小错误。

你可能也看到了 0.30000000000000004.com 这个网站，里面有一长串不同的编程语言，以及他们如何打印一个简单的表达式 0.1+0.2。在大多数情况下，你不会得到一个 0.3 的精确值。而且往往当你得到它的时候，它实际上是打印操作过程中四舍五入的结果。

在 Raku 中，0.1+0.2 正好是 0.3，而上面提到的单行本打印的是一个精确的零。

让我们深入到编译器的内部来看看这是如何工作的。Raku 的语法（在乐道编译器中实现）有以下检测数字的片段。

很有可能，你对 Raku 已经足够熟悉，你知道上述行为的解释是，它使用有理数来存储浮点数，比如 0.1。这是正确的，但看一下语法，你可以看到这个历程有点长。

语法中所谓的 rat_number 是一个写在角括号里的数字。

所以，如果你把程序改成:

那么你就会立即操作有理数。这里有一个相关的操作，可以转换这种格式的数字。

在某些时候，抽象语法树得到一个节点，其中包含一个 Rat 类型的常量，$nu 和 $de 部分作为分子和分母。

在我们的例子中，写成 0.1 形式的数字首先通过 dec_number 标记。

数字的整数和小数部分进入最终 Match 对象的 <int> 和 <frac> 键。这个语法标记的动作方法相当复杂。让我给你看看。

对于0.1、0.2和0.3这三个数字，上面的代码分别取它们的整数和小数部分，准备好两个整数 $parti 和 $partf，并将它们传递给与我们在 rat_number 动作中看到的相同的新常数的构造函数，之后就得到了一个Rat数。

现在我们跳过一些细节，看看你必须了解的有理数的另一个重要部分。

在我们的例子中，整数和小数部分得到的值如下。

如果你黑掉你本地的乐道文件副本，你可以很容易地自己看到它。

或者，在命令行中使用 --target=parse 选项。

一部分输出将包含我们想要看到的数据。

将数字以分数的形式呈现后，进行精确的计算就非常容易了，这就是为什么我们在输出中看到的是一个纯零。

回到我们的分数上。如果你同时打印分子和分母（例如使用裸体法），你会看到，如果可能的话，分数已经被归一化了。

如你所见，我们有 1/5，而不是 2/10，它代表的是同一个数，精度相同。当你使用这个数字时，你不应该担心找到两个分数的共同分界线，例如。