如果我有一个Role R定义为：
role R { method answer { 42 } }
这两行之间有什么区别（如果有的话）：
my $a = 'question' does R;
my $b = 'question' but R;
它们看起来非常相似：
say $a.answer; # OUTPUT: «42»
say $b.answer; # OUTPUT: «42»
say $a.WHAT; # OUTPUT: «(Str+{R})»
say $b.WHAT; # OUTPUT: «(Str+{R})»
这是一个有不止一种方法可以做到这一点的情况吗，这两者的意思是一样的？还是我遗漏了细微的差别？
注：
据我所知，does是既操作者和性状，因此当用于编译时混入（例如，可使用class C does R {}），而but仅仅是用于运行时混入。我也明白but可以与对象（例如，my $c = 'question' but False）does一起使用，而只能与Role. 我不是在问这些差异中的任何一个。我唯一的问题是在运行时使用Role …
Looking over my Raku code, I've realized that I pretty much never use CATCH blocks to actually catch/handle error. Instead, I handle errors with try blocks and testing for undefined values; the only thing I use CATCH blocks for is to log errors differently. I don't seem to be alone in this habit – looking at the CATCH blocks in the Raku docs, pretty much none of them handle the error in any sense beyond printing a message. (The …
是否可以CONTROL从特征中添加移相器？
按照docs 中的示例，在运行时代码中添加自定义控件异常很简单：
class CX::Oops does X::Control {};
sub f { CONTROL { when CX::Oops { note 'Oops!'; .resume}}
CX::Oops.new.throw; }
f; # OUTPUT: «Oops»
但是，我尝试从特征中这样做并没有奏效：
sub trait_mod:<is>(Sub $fn, :$oopsable) {
$fn.add_phaser: 'CONTROL', { when CX::Oops { note 'Oops!'; .resume} }}
sub g is oopsable { CX::Oops.new.throw; }
g; # OUTPUT: «control exception without handler»
从.has_phasers和fire_phasers（有趣的名字！）方法，我可以看出这是添加控制移相器。我需要做些什么来将其注册为处理程序，还是我还缺少其他东西？
The Rakudo implementation of Raku tracks multiple issues about the (very useful!) &?ROUTINE variable not providing the correct value (e.g., #1768 and 2362), so I realize that it's not behaving quite correctly. But I'm trying to understand what it's intended behavior is – which seems like an essential first step in fixing that behavior.
Running this code with Rakudo v2021.06 produces the output noted in the comments. Which parts of this output are correct, and which represent bugs?
sub …[我同时遇到了引发这个问题和上一个问题的问题，但我认为这两个问题应该分开。]
\n该文档描述了使用和变量进行解构赋值，但没有提及它是否可以与变量一起使用。但 Raku 足够一致，我决定尝试一下，而且它似乎有效：myourhas
class C { has $.a; has $.b }\nclass D { has ($.a, $.b) }\nC.new: :a<foo>; # OUTPUT: \xc2\xabC.new(a => "foo", b => Any)\xc2\xbb\nD.new: :a<foo>; # OUTPUT: \xc2\xabD.new(a => "foo", b => Any)\xc2\xbb\n然而，这种形式似乎打破了属性默认值：
\nclass C { has $.a; has $.b = 42 }\nclass D { has ($.a, $.b = 42) }\nC.new: :a<foo>; # OUTPUT: \xc2\xabC.new(a => "foo", b => 42)\xc2\xbb\nD.new: :a<foo>; # OUTPUT: \xc2\xabC.new(a …我知道列表赋值会使其左侧变平：
\nmy ($a, $b, $c);\n($a, ($b, $c)) = (0, (1.0, 1.1), 2);\nsay "\\$a: $a"; # OUTPUT: \xc2\xab$a: 0\xc2\xbb\nsay "\\$b: $b"; # OUTPUT: \xc2\xab$b: 1 1.1\xc2\xbb <-- $b is *not* 1\nsay "\\$c: $c"; # OUTPUT: \xc2\xab$c: 2\xc2\xbb <-- $c is *not* 1.1\n我也明白我们可以用来:($a, ($b, $c)) := (0, (1.0, 1.1))获得非扁平化行为。
我不明白的是为什么在列表分配期间左侧被展平。这是两个问题：首先，这种扁平化行为如何与语言的其余部分相适应？其次，自动展平是否允许任何在左侧不展平时不可能出现的行为？
\n关于第一个问题，我知道 Raku 历史上有很多自动扁平化行为。在Great List Refactor之前，像这样的表达式my @a = 1, (2, 3), 4会自动展平其右侧，从而产生 Array [1, 2, 3, 4]；同样，map许多其他迭代结构也会使他们的论点变得扁平化。不过，在 …
destructuring variable-assignment flatten assignment-operator raku
在编写并发代码时，想要分离一个单独的（绿色或操作系统）线程，然后要求该线程中的代码对各种线程安全消息做出反应是相当常见的。Raku 通过多种方式支持这种模式。
\n例如，文档中的许多Channel 示例显示的代码与下面的代码类似（跨两个线程打印 1 到 10）。
\nmy $channel = Channel.new;\nstart { react whenever $channel { say $_ }}\nfor ^10 { $channel.send($_) }\nsleep 1\n但是，如果我们从 s 的单消费者世界切换Channel到 live s 的多消费者世界Supply，则等效代码不再有效。
my Supplier $supplier .= new;\nstart { react whenever $supplier { say $_ }}\nfor ^10 { $supplier.emit($_) }\nsleep 1;\n该代码不打印任何内容。据我了解，这是因为react当值被编辑 \xe2\x80\x93 时该块没有监听，emit它不会花费很长时间来处理start线程和react事件，但处理emit十个值所需的时间甚至更少。而且，从逻辑上讲，将行移到循环sleep 1上方for会导致再次打印值。
毕竟，这很公平 \xe2\x80\x93，使用实时 …
如何像使用 Perl 的quotemeta 函数( \Q..\E) 那样转义 Raku 正则表达式中的元字符？
也就是 Perl 代码
my $sentence = 'The quick brown fox jumped over the lazy dog';
my $substring = 'quick.*?fox';
$sentence =~ s{$substring}{big bad wolf};
print $sentence
将每个.、*、 和?视为元字符，从而打印The big bad wolf jumped over the lazy dog。但是如果我将倒数第二行更改为$sentence =~ s{\Q$substring\E}{big bad wolf};，那么 Perl 会将其.*?视为文字字符，从而打印The quick brown fox jumped over the lazy dog。
如何按字面意思处理 Raku 正则表达式中的字符？
我如何构建 Raku 代码，以便某些符号在我正在编写的库中是公开的，但不对库的用户公开？（我说“库”是为了避免使用术语“分发”和“模块”，文档有时会以重叠的方式使用它们。但如果我应该使用更精确的术语，请告诉我。）
我了解如何在单个文件中控制隐私。例如，我可能有一个Foo.rakumod包含以下内容的文件：
unit module Foo;
sub private($priv) { #`[do internal stuff] }
our sub public($input) is export { #`[ code that calls &private ] }
使用此设置，&public是我图书馆公共 API 的一部分，但&private不是 - 我可以在 内调用它Foo，但我的用户不能。
如果&private变得足够大以至于我想将其拆分为自己的文件，我该如何保持这种分离？如果我&private进入 . Bar.rakumod，那么我将需要从模块中给它our（即包）范围和export它Bar，以便能够use从Foo. 但以同样的方式我出口这样&public的Foo会导致我的库的用户能够use Foo和呼叫&private-也就是结局我想避免的。如何维护&private的隐私？
（我通过在 META6.json 文件中将Foo我的分发版provides …
JavaScript 的事件循环使用消息队列来安排工作，并在开始下一条消息之前将每条消息运行到完成。因此，JavaScript 代码中一个小众但令人惊讶的常见模式是安排一个函数在当前队列中的消息使用setTimeout(fn, 0). 例如：
setTimeout(() => {console.log('first')}, 0);
console.log('second');
// OUTPUT: "second\nfirst"
（有关更多详细信息，请参阅MDN 的描述。）
Raku's 是否提供任何类似的方法来在所有当前计划的工作完成后立即安排工作？根据我对 Raku 并发模型的理解（主要来自这篇 6guts 帖子），似乎 Raku 使用了类似的消息队列（尽管如果有误，请纠正我！）。我最初认为这Promise.in(0).then: &fn是一个直接的等价物：
my $p = Promise.in(0).then: { say 'first' }
say 'second';
await $p;
# OUTPUT: «second\nfirst» # ...usually
但是，在运行上面的代码很多次后，我意识到，这只是建立一个竞争条件和'first'是有时第一。那么，是否有任何 Raku 代码提供相同的行为？而且，如果是这样，这种行为是否是 Raku/Roast 决定的有意语义的结果，而不是（可能是临时的）实现细节的结果？
raku ×10
rakudo ×8
compile-time ×2
exception ×2
composition ×1
concurrency ×1
constructor ×1
escaping ×1
event-loop ×1
flatten ×1
goto ×1
javascript ×1
mixins ×1
modifier ×1
module ×1
oop ×1
private ×1
quotemeta ×1
regex ×1