希望“事件”这个词在拉库兰没有用词不当。据我了解，Supplies相当于 NodeJS 等其他编程语言中“事件”的 Raku 版本。emit在 NodeJS 中，您可以注册不同的事件，这些事件可以通过 的第一个参数专门指定。在 Raku 中可以做到这一点吗？
const EventEmitter = require('events');
const eventEmitter = new EventEmitter();
eventEmitter.on('start', () => {
console.log('started');
});
eventEmitter.on('end', (value) => {
console.log(`ended ${value}` );
});
eventEmitter.emit('start');
eventEmitter.emit('end', 23);
我正在阅读《很好的用品：处理异步数据的语法救济》（我还没有完成），我看到 jnthn 实现了订阅机制subscribe，send所以我想知道这是否是解决问题的方法。
这里的问题是我不太明白控制流中语句和块之间的区别。
查看三元运算符，我可以使用它来分配变量。但这是一个运算符，所以它就像应用一个函数——不是吗？
> my $variable = True ?? 34 !! 42;
34
因为在 raku 文档中说：
if要有条件地运行代码块，请使用
if后跟条件。条件，一个表达式，将在语句if结束前立即计算。附加到条件的块只会在条件意味着True强制为 Bool 时进行评估。与某些语言不同，条件不必用括号括起来，而是块{和}周围是强制性的：
do运行不能是独立语句的块的最简单方法是
do在它之前写入：
所以这应该适用于两种情况：
> my $variable = do {34};
34
> my $variable = if True {34;} else {43;}
===SORRY!===
Word 'if' interpreted as a listop; please use 'do if' to introduce the statement control word
------> my $variable = if? True {34;} else {43;} …我写了一个简单的代码：
\nsub euler-ex ($x) of Seq {\n 1, { $x**++$ / [\xc3\x97] 1 .. ++$ } ... Inf }\nsay " 5: " ~ euler-ex(5)[^20] ~ " = " ~ [+](euler-ex(5)[^20]);\n输出：
\n5: 1 5 12.5 20.833333 26.041667 26.041667 21.701389 15.500992 9.68812 5.382289 2.6911445 1.22324748 0.50968645 0.19603325 0.07001187499 0.023337291662 0.0072929036444 0.00214497166011 0.000595825461143 0.000156796173985 = 148.41310786833832\n如何指定该输出的位数，即来自序列的显式生成器的小数位数？
\n来自这个 SO question，我试图将一个List（或非标量的东西，一般来说）作为分配给哈希键的值，这样：
my %syns-by-name does Associative[Str,List] = Bq => ("Bq", "becquerel", "becquerels");
my Str @syns = %syns-by-name<Bq>;
然而，这是行不通的。列表在分配之前逐项列出，因此值始终是标量。您需要采取一种解决方法来实际完成这项工作：
my %syns-by-name does Associative[Str,List] = Bq => ("Bq", "becquerel", "becquerels");
my @list := <C coulomb coulombs>;
%syns-by-name<C> := @list;
my Str @syns = %syns-by-name<C>;
say @syns;
这将返回我们正在寻找的内容，一个列表。但是，我们怎么能直接在作业上做到这一点并说服一个列表是一个列表而不是一个逐项列表呢？
在计算器上关于最近的问题混入在乐都激起了我的兴趣，以混入是否可以适用于重复出现在其他编程语言的特点。
例如，在R语言中，可以给向量的元素起一个名字（即属性），这对于数据分析非常方便。有关一个很好的示例，请参阅Andrie de Vries 和 Joris Meys 的“How to Name the Values in Your Vectors in R”，他们使用R的内置islands数据集说明了此功能。下面是一个更普通的例子（代码在 R-REPL 中运行）：
> #R-code
> x <- 1:4
> names(x) <- LETTERS[1:4]
> str(x)
Named int [1:4] 1 2 3 4
- attr(*, "names")= chr [1:4] "A" "B" "C" "D"
> x
A B C D
1 2 3 4
> x[1]
A
1
> sum(x)
[1] 10
下面我尝试使用 de Vries 和 MeysR使用的相同 …
所以说乐拥有多重继承已经不是什么秘密了，这让我想知道：“乐如何以合理的方式处理它？”
一些初步测试表明默认行为是从继承列表中的第一个类继承的，这很好，许多其他语言也是这样做的
class A {
has $.foo = 0;
method speak {...}
}
class B is A {
has $.foo = 1;
method speak {
say 'moo';
}
}
class C is A {
has $.foo = 2;
method speak {
say 'baa';
}
}
class D is B is C {}
class E is C is B {}
say D.new.foo; # prints 1 (from B)
say E.new.foo; # prints 2 (from C)
但这让我想知道，如果我想D使用C's …
我想知道如何在运行时通过名称动态访问对象的属性。代替：StrRaku
#!/usr/bin/rakudo
class c0 {
has $!a0 = 1;
has $!a1 = 2;
method access(Str $m) {
if ($m eq "a0") { return $!a0; }
if ($m eq "a1") { return $!a1; }
}
method set(Str $m, $v) {
if ($m eq "a0") { $!a0 = $v; }
if ($m eq "a1") { $!a1 = $v; }
}
}
my $c = c0.new();
$c.set("a0", 3);
$c.set("a1", 4);
say $c.access("a0");
say $c.access("a1");
我想使用一些看起来像伪代码的东西：
class c0 {
... …目前（截至 2020 年 8 月）Rakudo 不会在编译时对函数的返回值进行类型检查；也就是说，它不提供函数满足其返回约束的静态保证。具体来说，以下两个函数都编译为 Raku：
sub get-int(--> Int) { 'bug' }
sub get-int($a --> Int) {
when $a == 5 { 'Rare bug' }
default { 42 }
}
我有两个相关的问题：
有没有办法知道当前在编译时发生了什么（如果有）类型检查？（通过某人编写的列表，文档中的某处，或 Rakudo 源中的中心位置）还是比这更临时？
缺乏编译时类型检查是否是有意的设计决策？或者正在添加更多静态类型检查的东西，有一天会很高兴，但还没有实现？
（我熟悉 Johnathan 对Raku 中类型/约束的性能惩罚？的精彩回答，其中指出“Raku 要求写入程序的类型约束最迟在运行时强制执行。”该答案描述了避免运行的各种方法- 类型检查的时间成本，但没有描述在编译时完成的类型检查（如果有的话）（这肯定会避免运行时成本！）。
我想用希伯来语处理整个 Tanach 文件。为此，我选择了 Raku 语言，因为它的一些特性（语法和 unicode 支持）。
因此，我定义了一些标记来选择相关数据。
grammar HEB {
token TOP {'<hebrewname>'<t_word>'</hebrewname>'}
token t_word {<graph>+}
};
grammar CHA {
token TOP {'<c n="'<t_number>'">'}
token t_number {\d+}
};
grammar VER {
token TOP {'<v n="'<t_number>'">'}
token t_number {\d+}
};
grammar WOR {
token TOP {'<w>'<t_word>'</w>'}
token t_word {<graph>+}
};
在这里，文档的一小部分（XML 格式的 Tanach）足以说明问题：
<names>
<name>Genesis</name>
<abbrev>Gen</abbrev>
<number>1</number>
<filename>Genesis</filename>
<hebrewname>??????</hebrewname>
</names>
<c n="1">
<v n="1">
<w>???/?????????</w>
<w>???????</w>
<w>?????????</w>
<w>????</w>
<w>??/??????????</w>
<w>??/????</w>
<w>??/???????</w>
</v>
<v n="2">
<w>??/??/??????</w>
<w>????????</w>
<w>???????</w>
<w>??/??????</w>
<w>??/????????</w>
<w>????</w> …
我发现了这个 JS 代码片段：
function append(demo = "", file = "") {
const extra = "ctl=1&embed=1";
if (demo && file) return `/${demo}/?file=${file}&${extra}`;
if (!demo && file) return `/?file=${file}&${extra}`;
if (demo && !file) return `/${demo}&${extra}`;
return `?${extra}`;
}
我可以使用ifs 轻松地将其移植到 Raku，但我认为使用given/when将是展示该功能的好方法。我想出了以下几点：
sub append(Str :$demo, Str :$file) {
my $extra = "ctl=1&embed=1";
given ($demo, $file) {
when $demo.so, $file.so { "/$demo/?file=$file&$extra" }
when $demo.not, $file.so { "/?file=$file&$extra" }
when $demo.so, $file.not { "/$demo?$extra" }
default { "?$extra" …我试图.bed通过识别前两列chr并start遵循此来合并多个文件，
但是，我想知道如何使文件名成为新添加的列名。
$cat combineFWPS_02.sh
BEGIN {
for (k=1; k<ARGC; ++k)
s = s " " 0
}
FNR == 1 {
++ARGIND
}
{
key=$1 OFS $2
if (!(key in map))
map[key] = s
split(map[key], a)
a[ARGIND] = $3
v = ""
for (k=1; k<ARGC; ++k)
v = v " " a[k]
map[key]=v
}
END {
for (k in map)
print k map[k]
}
$cat comRwps_02.sh
awkCOM="~/scripts/combineFWPS_02.sh"
## Run the jobs
time awk …根据维基百科，2017 年，使用大写字母\xe1\xba\x9e(Unicode U+1E9E) 被正式采用——至少作为一种选择——实际上可能是德语中全大写单词的子集：
同年 6 月，德国正字法委员会正式通过了一项规则，\xe2\x9f\xa8\xe1\xba\x9e\xe2\x9f\xa9 将成为 \xe2\x9f\xa8\xc3\x9f 大写的选项\xe2\x9f\xa9 除了之前的大写形式 \xe2\x9f\xa8SS\xe2\x9f\xa9 之外（即变体 STRASSE 和 STRA\xe1\xba\x9eE 将被视为同等有效）。2
\n似乎对德语的这一补充将大大简化字符串之间的大小写比较（所谓的“大小写折叠”或“折叠大小写”比较）。注意，我开始这个询问是为了理解 Raku（又名 Perl6）的实现，但实际上这个问题似乎可以推广到其他编程语言。这是 Raku 的默认实现 - 从rfdr_Regeln_2017.pdf中的 13 个单词开始，这些单词已小写（通过 Raku 的.lc函数）：
~$ cat TO_\xe1\xba\x9e_OR_NOT_TO_\xe1\xba\x9e.txt\nma\xc3\x9f stra\xc3\x9fe grie\xc3\x9f spie\xc3\x9f gro\xc3\x9f gr\xc3\xbc\xc3\x9fen au\xc3\x9fen au\xc3\x9fer drau\xc3\x9fen strau\xc3\x9f bei\xc3\x9fen flei\xc3\x9f hei\xc3\x9fen\n~$ raku -ne \'.words>>.match(/^ <:Ll>+ $/).say;\' TO_\xe1\xba\x9e_OR_NOT_TO_\xe1\xba\x9e.txt\n(\xef\xbd\xa2ma\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2stra\xc3\x9fe\xef\xbd\xa3 \xef\xbd\xa2grie\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2spie\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2gro\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2gr\xc3\xbc\xc3\x9fen\xef\xbd\xa3 \xef\xbd\xa2au\xc3\x9fen\xef\xbd\xa3 \xef\xbd\xa2au\xc3\x9fer\xef\xbd\xa3 \xef\xbd\xa2drau\xc3\x9fen\xef\xbd\xa3 \xef\xbd\xa2strau\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2bei\xc3\x9fen\xef\xbd\xa3 \xef\xbd\xa2flei\xc3\x9f\xef\xbd\xa3 \xef\xbd\xa2hei\xc3\x9fen\xef\xbd\xa3)\n~$ raku -ne \'.uc.say;\' TO_\xe1\xba\x9e_OR_NOT_TO_\xe1\xba\x9e.txt\nMASS STRASSE GRIESS …