那是Perl 6哈希还是块？

Question

这是一种可能会咬伤初学者的意外行为。首先，这是有意的吗？其次，Perl 6还使用哪些其他东西来猜测要创建哪个对象？它一开始是认为它是块还是散列，然后再更改，还是最终决定？

可以使用大括号和fat箭头构造哈希：

my $color-name-to-rgb = {
    'red' => 'FF0000',
    };

put $color-name-to-rgb.^name;  # Hash

使用另一对表示法也会创建一个哈希。

my $color-name-to-rgb = {
    :red('FF0000'),
    };

但是，如果没有胖箭头，我会得到一个方块：

my $color-name-to-rgb = {
    'red', 'FF0000',
    };

put $color-name-to-rgb.^name;  # Block

哈希文档只提到在大括号内使用$\uCode创建块。

还有其他方法可以定义哈希，但我询问的是这种特定的语法，而不是寻找我已经知道的解决方法。

$ perl6 -v
This is Rakudo version 2017.04.3 built on MoarVM version 2017.04-53-g66c6dda
implementing Perl 6.c.

Answer 1

首选的Perl6方法是使用%（）创建哈希。

my $color-name-to-rgb = %(
    'red', 'FF0000',
    );

我不建议人们使用大括号来创建散列，如果他们想创建散列，那么%( )是正确的方法。

如果您来自Perl 5世界，最好养成在创建哈希时使用<代码>%（）<代码>而不是<代码>{}<代码>的习惯。

Answer 2

您的问题¹和此答案仅适用于术语位置²中的括号块。

完全遵循下面解释的规则的大括号代码构造哈希：

say WHAT {                  }             # (Hash)
say WHAT { %foo             }             # (Hash)
say WHAT { %foo, ...        }             # (Hash)
say WHAT { foo => 42, ...   }             # (Hash)
say WHAT { :foo, ...        }             # (Hash)
say WHAT { key => $foo, ... }             # (Hash)

如果块是空的，或者只包含一个列表，其第一个元素是一个sigil'd变量（例如foo）或一个文本对（例如bar），并且它没有签名或包含顶级语句，那么它就是一个Hash。否则它就是一个块。

>

强制执行{…}术语要构造块而不是散列，请编写一个 开头，即<代码>{；…} 。

要编写空的Block术语，请编写{；}。

要编写空Hash术语，请编写{}。

要强制{...}术语构造Hash而不是Block，请遵循规则（在本答案的其余部分中详细解释），或改为编写%（...）。

一些带大括号的代码具有显式签名，即它具有显式参数，如下面的$foo。无论大括号内有什么，它总是构造一个块：

say WHAT         { key => $foo, 'a', 'b' } # (Hash)
say WHAT -> $foo { key => $foo, 'a', 'b' } # (Block)

一些带大括号的代码有一个隐式签名，该签名是由于在块内显式选择编码而生成的：

>

在{...}中使用“代词”意味着它是具有签名的Block（如果它还没有显式签名，则是隐式签名）。代词是$_、@_和%_。

这包括由于没有左侧参数的. method调用而在{...}中隐含使用$_。换句话说，由于. foo缺乏左侧参数，即使{. foo}也有签名（(;; $ _？是原始的））。

使用“占位符”变量（例如，$^foo）。

与显式签名一样，如果大括号中的代码具有隐式签名，则无论大括号中有什么内容，它都会构造一个块：

say WHAT { key => $_ }                     # (Block)
say WHAT { key => 'value', .foo, .bar }    # (Block)

say WHAT { :foo; (do 'a'), (do 'b') }     # (Block)
say WHAT { :foo, (do 'a'), (do 'b') }     # (Hash)

第二行包含多个语句，但它们在一个列表的单个元素中生成值，该列表是一个顶级表达式。

声明是一种声明，但我已经包含了这一部分，以防有人没有意识到这一点。

say WHAT { :foo, $baz, {my $bar} }        # (Hash)
say WHAT { :foo, $baz, (my $bar) }        # (Block)

第一行包含一个块，作为包含声明的键（my$bar）。但该声明属于内部的{my$bar}块，而不是外部的{…} 。因此，内部块与外部块一样，只是一个值 ，因此外括号代码仍被解释为哈希。

相反，第二行直接在外部{代码>{…}中声明一个变量 。所以这是一个块。

回想一下，要成为散列，大括号代码的内容必须是以sigil'd变量或文本对开头的列表。所以这些都会产生块：

my $bar = key => 'value';
say WHAT { $bar, %baz }                   # (Block)
say WHAT { |%baz      }                   # (Block)
say WHAT { %@quux     }                   # (Block)
say WHAT { 'a', 'b', key => $foo }        # (Block)
say WHAT { Pair.new: 'key', $foo }        # (Block)

1这个“HashorBlock？”问题是DWIM设计的一个例子。在Raku文化中，良好的DWIM设计被认为是一件好事。但是每个DWIM都带有相应的WAT3。良好的DWIM设计的关键是确保，总的来说，WAT的吠叫比它们的叮咬更糟糕4；并且吠叫是有用的5；并且DWIM的净收益被认为远远超过所有吠叫和叮咬。6

术语是Raku对英语中名词或名词短语的类比。这是一个价值观。

作为术语的支撑块示例：

.say given { ... }  # closure? hash?
say 42, { ... }     # closure? hash?

非术语的支撑块示例：

if True { ... }     # always a closure
class foo { ... }   # always a package
put bar{ ... }      # always a hash index

此答案仅讨论作为术语的括号块。有关术语的更多详细信息，或更具体地“术语位置”（语法中括号块将被解释为术语的位置），请参阅此答案下方的注释。

WAT指的是开发人员在某些事情看起来很疯狂时的难以置信的惊讶。众所周知，即使对于设计精良的DWIM，对于每一个在大多数情况下适用于大多数人的DWIM，也不可避免地会有一个或多个相关的WAT，有时会让一些人感到惊讶，包括一些在其他时候从DWIM中受益的人。

4与此DWIM相关的WAT的咬合程度各不相同。通常是树皮（错误消息）使问题变得明显。但它也可能更加模糊：

say { a => 42 }() ;  # No such method 'CALL-ME' for invocant of type 'Hash'   WAT? Oh.
say { a => $_ }<a> ; # Type Block does not support associative indexing.      WAT? Oh.

say { a => $_, b => 42, c => 99 } .elems  # 1                                 WAT?????

“吠叫”是文档中的错误消息或警告。这些通常可以改进。cf锁。protect（{}）失败，但出现了令人惊讶的消息。

社区成员对DWIM总体设计或任何特定DWIM设计是否值得持有不同意见。cf我的观点与Sam对这个问题的回答。