does QuantHash
加权对象集合的角色。请参阅 Bag、BagHash 和 Mixy。
方法§
方法 new-from-pairs§
method new-from-pairs(Baggy: * --> Baggy)
根据作为位置参数给出的 Pair 对象列表构造一个 Baggy 对象
say Mix.new-from-pairs: 'butter' => 0.22, 'sugar' => 0.1, 'sugar' => 0.02;# OUTPUT: «Mix(butter(0.22) sugar(0.12))»
注意：确保您没有意外地将 Pairs 作为位置参数传递；上面示例中键周围的引号很重要。
方法 grab§
multi method grab(Baggy: --> Any)multi method grab(Baggy: --> Seq)
与 pick 类似，grab 根据与每个键对应的值加权返回随机选择的元素。与 pick 不同，它仅适用于可变结构，例如 BagHash。在不可变结构上使用 grab 会导致 X::Immutable 异常。如果将 * 作为 $count 传递，或者 $count 大于或等于调用者的 total，则调用者的 total 个元素将按随机顺序返回；即它们以随机顺序返回。
Grab 会将被抓取键的权重减一（当权重达到 0 时删除该键）。根据定义，调用者的 total 也会减少一，因此概率在随后的 grab 操作中保持一致。
my = ('Ford' => 2, 'Rover' => 3).BagHash;say .grab; # OUTPUT: «Ford»say .grab(2); # OUTPUT: «(Rover Rover)»say .grab(*); # OUTPUT: «(Rover Ford)»my = ('eggs' => 2, 'bacon' => 3).Bag;say .grab;CATCH ;# OUTPUT: «X::Immutable: Cannot call 'grab' on an immutable 'Bag'»
方法 grabpairs§
multi method grabpairs(Baggy: --> Any)multi method grabpairs(Baggy: --> Seq)
根据调用的方法版本返回 Pair 或 Seq 的 Pair。返回的每个 Pair 都具有调用者的元素作为其键，并具有元素的权重作为其值。与 pickpairs 不同，它仅适用于可变结构，例如 BagHash。在不可变结构上使用 grabpairs 会导致 X::Immutable 异常。如果将 * 作为 $count 传递，或者 $count 大于或等于调用者的 elements 的数量，则调用者的所有元素/权重 Pair 将按随机顺序返回。
grabpairs 与 pickpairs 的不同之处在于，“抓取”的元素实际上已从调用者中移除。
my = (eggs => 2, bacon => 3).BagHash;say .grabpairs; # OUTPUT: «bacon => 3»say ; # OUTPUT: «BagHash.new(eggs(2))»say .grabpairs(1); # OUTPUT: «(eggs => 2)»say .grabpairs(*); # OUTPUT: «()»my = ('eggs' => 2, 'bacon' => 3).Bag;say .grabpairs;CATCH ;# OUTPUT: «X::Immutable: Cannot call 'grabpairs' on an immutable 'Bag'»
方法 pick§
multi method pick(Baggy: --> Any)multi method pick(Baggy: --> Seq)
与普通列表 pick 类似，但返回调用者的键，其权重由其值决定，就好像键被复制了与对应值指示的次数一样，然后使用列表 pick。用于挑选的基本隐喻是，你正在从袋子里取出彩色的弹珠。（有关“带替换挑选”，请参阅 roll）。如果将 * 传递为 $count，或者 $count 大于或等于调用者的 total，则调用者中的 total 元素将以随机顺序返回。
请注意，每个 pick 调用都维护其自己的私有状态，并且不会对后续的 pick 调用产生影响。
my = bag <eggs bacon bacon bacon>;say .pick; # OUTPUT: «eggs»say .pick(2); # OUTPUT: «(eggs bacon)»say .total; # OUTPUT: «4»say .pick(*); # OUTPUT: «(bacon bacon bacon eggs)»
方法 pickpairs§
multi method pickpairs(Baggy: --> Pair)multi method pickpairs(Baggy: --> Seq)
根据调用的方法版本，返回 Pair 或 Seq 的 Pair。返回的每个 Pair 都将调用者的元素作为其键，并将元素的权重作为其值。这些元素在“挑选”时不进行替换。如果将 * 传递为 $count，或者 $count 大于或等于调用者的 elements 的数量，则调用者中的所有元素/权重 Pair 将以随机顺序返回。
请注意，每个 pickpairs 调用都维护其自己的私有状态，并且不会对后续的 pickpairs 调用产生影响。
my = bag <eggs bacon bacon bacon>;say .pickpairs; # OUTPUT: «eggs => 1»say .pickpairs(1); # OUTPUT: «(bacon => 3)»say .pickpairs(*); # OUTPUT: «(eggs => 1 bacon => 3)»
方法 roll§
multi method roll(Baggy: --> Any)multi method roll(Baggy: --> Seq)
与普通列表 roll 类似，但返回调用者的键，其权重由其值决定，就好像键被复制了与对应值指示的次数一样，然后使用列表 roll。用于滚动的基本隐喻是，你正在掷 $count 个彼此独立的骰子，这（用袋子术语来说）相当于从袋子里挑选一个彩色的弹珠，然后放回去，并执行此操作 $count 次。在骰子术语中，弹珠的数量对应于面的数量，而相同颜色的弹珠的数量对应于具有相同颜色的面的数量。（有关“不带替换挑选”，请参阅 pick）。
如果将 * 传递给 $count，则返回一个惰性、无限的序列，其中包含从调用者中随机选择的元素。
my = bag <eggs bacon bacon bacon>;say .roll; # OUTPUT: «bacon»say .roll(3); # OUTPUT: «(bacon eggs bacon)»my := .roll(*);say [^5]; # OUTPUT: «(bacon eggs bacon bacon bacon)»
方法 pairs§
method pairs(Baggy: --> Seq)
将所有元素及其各自的权重作为 Seq 的 Pair 返回，其中键是元素本身，而值是该元素的权重。
my = bag <bacon eggs bacon>;my = .pairs;say .sort; # OUTPUT: «(bacon => 2 eggs => 1)»
方法 antipairs§
method antipairs(Baggy: --> Seq)
将所有元素及其各自的权重作为 Seq 的 Pair 返回，其中元素本身是值，该元素的权重是键，即方法 pairs 的相反。
my = bag <bacon eggs bacon>;my = .antipairs;say .sort; # OUTPUT: «(1 => eggs 2 => bacon)»
方法 invert§
method invert(Baggy: --> Seq)
将所有元素及其各自的权重作为 Seq 的 Pair 返回，其中元素本身是值，该元素的权重是键，即方法 pairs 的相反。除了某些特殊情况外，Baggy 类型上的 invert 返回的结果与 antipairs 相同。
my = bag <bacon eggs bacon>;my = .invert;say .sort; # OUTPUT: «(1 => eggs 2 => bacon)»
方法 classify-list§
multi method classify-list(, * --> Baggy)multi method classify-list(, * --> Baggy)multi method classify-list(, * --> Baggy)
通过使用给定的 mapper 对可能为空的 @list 值进行分类，来填充一个可变的 Baggy。@list 不能是惰性的。
say BagHash.new.classify-list: , ^10;# OUTPUT: BagHash(even(5) odd(5))my = <zero one two three four five>;say MixHash.new.classify-list: , 1, 2, 3, 4, 4, 6;# OUTPUT: MixHash((Any) two three four(2) one)
mapper 可以是 Callable，它接受单个参数，一个 Associative 或一个 Iterable。对于 Associative 和 Iterable mapper，@list 中的值分别表示 mapper 值的键和索引。Callable mapper 将针对 @list 中的每个项目执行一次，其中该项目作为参数，其返回值将用作 mapper 的值。
mapper 的值用作 Baggy 的键，Baggy 将增加 1。如果你希望将一个项目同时分类到多个类别，请参见 .categorize-list。
注意：与 Hash 的 .classify-list 不同，返回 Iterable mapper 的值将抛出异常，因为 Baggy 类型不支持嵌套分类。出于同样的原因，Baggy 的 .classify-list 不接受 :&as 参数。
方法 categorize-list§
multi method categorize-list(, * --> Baggy)multi method categorize-list(, * --> Baggy)multi method categorize-list(, * --> Baggy)
通过使用给定的 mapper 对可能为空的 @list 值进行分类，来填充一个可变的 Baggy。@list 不能是惰性的。
say BagHash.new.categorize-list:, ^10;# OUTPUT: BagHash(largish(4) even(5) non-prime(6) prime(4) odd(5))my = :sugar<sweet white>, :lemon<sour>, :cake('sweet', 'is-a-lie');say MixHash.new.categorize-list: , <sugar lemon cake>;# OUTPUT: MixHash(is-a-lie sour white sweet(2))
mapper 可以是 Callable，它接受单个参数，一个 Associative 或一个 Iterable。对于 Associative 和 Iterable mapper，@list 中的值分别表示 mapper 值的键和索引。Callable mapper 将针对 @list 中的每个项目执行一次，其中该项目作为参数，其返回值将用作 mapper 的值。
mapper 的值用作 Baggy 的键的可能为空的列表，Baggy 将增加 1。
注意：与 Hash 的 .categorize-list 不同，返回 Iterables 列表作为 mapper 的值将抛出异常，因为 Baggy 类型不支持嵌套分类。出于同样的原因，Baggy 的 .categorize-list 不接受 :&as 参数。
方法 keys§
method keys(Baggy: --> Seq)
返回 Baggy 对象中所有键的 Seq，而不考虑其各个权重，与 kxxv 相反。
my = bag <eggs spam spam spam>;say .keys.sort; # OUTPUT: «(eggs spam)»my = ("a" => 5, "b" => 2).BagHash;say .keys.sort; # OUTPUT: «(a b)»
方法值§
method values(Baggy: --> Seq)
返回一个Seq，其中包含Baggy对象中所有值，即权重。
my = bag <eggs spam spam spam>;say .values.sort; # OUTPUT: «(1 3)»my = ("a" => 5, "b" => 2, "a" => 1).BagHash;say .values.sort; # OUTPUT: «(2 6)»
方法 kv§
method kv(Baggy: --> Seq)
返回一个Seq，其中包含交错的键和值。
my = bag <eggs spam spam spam>;say .kv; # OUTPUT: «(spam 3 eggs 1)»my = ("a" => 5, "b" => 2, "a" => 1).BagHash;say .kv; # OUTPUT: «(a 6 b 2)»
方法 kxxv§
method kxxv(Baggy: --> Seq)
返回一个Seq，其中包含调用者的键，每个键都乘以其权重。请注意，kxxv仅适用于具有整数权重的Baggy类型，即Bag和BagHash。
my = bag <spam eggs spam spam bacon>;say .kxxv.sort; # OUTPUT: «(bacon eggs spam spam spam)»my = ("a" => 0, "b" => 1, "b" => 2).BagHash;say .kxxv; # OUTPUT: «(b b b)»
方法 elems§
method elems(Baggy: --> Int)
返回Baggy对象中的元素数量，而不考虑各个元素的权重。
my = bag <eggs spam spam spam>;say .elems; # OUTPUT: «2»my = ("b" => 9.4, "b" => 2).MixHash;say .elems; # OUTPUT: «1»
方法 total§
method total(Baggy:)
返回Baggy对象中所有元素的权重之和。
my = bag <eggs spam spam bacon>;say .total; # OUTPUT: «4»my = ("a" => 5, "b" => 1, "b" => 2).BagHash;say .total; # OUTPUT: «8»
方法 default§
method default(Baggy: --> 0)
返回零。
my = bag <eggs bacon>;say .default; # OUTPUT: «0»
方法 hash§
method hash(Baggy: --> Hash)
返回一个Hash，其中调用者的元素是键，其各自的权重是值。
my = bag <eggs bacon bacon>;my = .hash;say .^name; # OUTPUT: «Hash[Any,Any]»say ; # OUTPUT: «{bacon => 2, eggs => 1}»
方法 Bool§
method Bool(Baggy: --> Bool)
如果调用者至少包含一个元素，则返回True。
my = ('eggs' => 1).BagHash;say .Bool; # OUTPUT: «True»# (since we have one element)<eggs> = 0; # weight == 0 will lead to element removalsay .Bool; # OUTPUT: «False»
方法 Set§
method Set(--> Set)
my = (eggs => 2, bacon => 3).BagHash;say .Set; # OUTPUT: «Set(bacon eggs)»
方法 SetHash§
method SetHash(--> SetHash)
my = (eggs => 2, bacon => 3).BagHash;my = .SetHash;say .^name; # OUTPUT: «SetHash»say .elems; # OUTPUT: «2»
方法 ACCEPTS§
method ACCEPTS( --> Bool)
如果右侧是一个Baggy，则在智能匹配中使用。
如果右侧是类型对象，即Baggy，则如果$otherdoesBaggy，则该方法返回True，否则返回False。
如果右侧是一个Baggy对象，则仅当$other具有与调用者相同的元素和相同的权重时，才返回True。
my = bag <eggs bacon>;say ~~ Baggy; # OUTPUT: «True»say .does(Baggy); # OUTPUT: «True»my = (eggs => 1, bacon => 1).Mix;say ~~ ; # OUTPUT: «True»my = (eggs => 1, bacon => 2).Bag;say ~~ ; # OUTPUT: «False»
另请参阅§
类型图§
Baggy的类型关系