Backup: Array in Perl6

Array类

继承List,而List又继承Iterable,Positional,Cool，这样说明Array是有序的，可迭代的数据列表。和Perl 5 一样，Perl 6也有数组push/pop/shift/unshift/的方法，不过push/unshift的如果是数组，则会保留数据结构，而不会展开。

ARRAY.pop
ARRAY.shift
ARRAY.push: VALUES
ARRAY.push(VALUES)
ARRAY.unshift: VALUES
ARRAY.unshift(VALUES)
#不像Perl5中，会把VALUES数组flatten，Perl6会保留数据结构

#可以同时指定多个值，用逗号隔开
ARRAY.append(LIST)
ARRAY.append: LIST
ARRAY.prepend(LIST)
ARRAY.prepend: LIST
#append就像perl5中的push了，会flatten

ARRAY.splice(START, ELEMS?, REPLACEMENT?)
#删除，替换，这个方法会修改原数组
#返回删除的部分

ARRAY.shape
#返回数组的维度,相当于R的dim()

需要注意

• append 才是Perl5中的 push，6默认的push是保留数据结构的
• prepend 和 unshift 也类似
• splice 是会修改数组的而不是简单的获取

继承自List类

基本操作

LIST.elems     #list中元素个数
LIST.end       #最后一个元素的index，perl5中用 $#LIST
LIST.keys      #返回indexes数组 0..(@list.elems-1)
LIST.values
LIST.kv        #返回index,value的Pair
LIST.pairs     #返回hash那样的
LIST.join(SEP)
LIST.map(CODE)
#可以根据CODE里面的需求，传入同时一个或多个元素，不限于一个

LIST.Bool #是否有元素
LIST.Str  # .join(' ')之后返回一个字符串，相当于简便的join
LIST.Int  # .elems LIST.Numeric
LIST.sum #如果有元素无法转成数字，throw an exception

获取部分元素

LIST.head(NUMBER)
#返回前几个，默认是一个，借鉴linux的head/tail
LIST.tail(NUMBER)

LIST.pick(COUNT)
#不重复取样，不放回取样
#如果传入*,表示COUNT大于等于数组长度，相当于打乱了整个数组顺序返回

LIST.roll(COUNT)
#有放回取样，数值完全可以大于LIST长度
如果传入*,返回一个lazy, infinite sequence of randomly chosen elements

匹配、筛选、分类

LIST.flat
LIST.flatmap(CODE) #flat之后再map

LIST.grep(MATCHER, :RETURN_AS)
#相对Perl5增加了:RETURN_AS,可以是:k,:v,:kv,:p

LIST.first(MATCHER, :RETURN_AS, :FROM_END)
#查找第一个匹配的返回
#:end search should be from the end of the list
#:k,:kv,:p，并没有:v

classify MAPPER, LIST
LIST.classify(MAPPER)
#按条件分类，分类的类别作为key,分类的值作为value，返回一个hash
#例如，按奇偶数分类
say (1, 7, 6, 3, 2).classify: { $_ %% 2 ?? 'even' !! 'odd' };
#even => 6 2, odd => 1 7 3
#例如，按转换成字符串的长度分类
say ('hello', 1, 22/7, 42, 'world').classify: { .Str.chars };
#1 => 1, 2 => 42, 5 => hello world, 8 => 3.142857

翻转、滚动，去重复，排序

LIST.eager
#我没看懂这个有什么鸟用
LIST.reverse
LIST.rotate
#这个shift前几个，append到数组末尾，相当于是向左滚动(正数)，可以是负数
LIST.sort(SORT_BY)
#默认使用<cmp>,接受2个参数

LIST.unique(:COMPARE_AS, :COMPARE_WITH)
#使用===比较，返回保持顺序
#:as对比较的值作何处理再比 :with什么才算unique(标准)
LIST.repeated(:COMPARE_AS, :COMPARE_WITH)
#返回重复的值

LIST.squish(:COMPARE_AS)
#把相邻的一样的值去重，只保留一个，像tr///d

reduce

LIST.reduce(CODE)
#这个在Perl5中是Scalar::Util类中有
#mplicit loop, responds to next, last and redo statements.
my @ops = [Z] (<+ - * />, 1..20)».roll(4);
say ('x', |@ops).reduce: -> $formula, [$op, $number] {
    Bool.pick ?? "($formula $op $number)"
              !! "($number $op $formula)"
}
#[Z] zip the following list
#» or >> is the hyper method call operator，就是
#在每一个元素上call紧跟其后的方法，这个例子中
#就是分别在<+ - * />上call roll(4)选出4个，再在1..20上call roll(4)选出4个
#| flatten Pair List, Hash, Capture等

排列组合

LIST.combinations(INTEGER)
LIST.combinations(RANGE)
#上面的是组合，如果给出一个数字，例如3，返回
# 3个一组的所有组合；也可以给范围，则范围里的每种组合都返回
#还有一种形式
combinations INTEGER_A, INTEGER_B
(^INTEGER_A).combinations(INTEGER_B)
#是0到INTEGER_A的数的INTEGER_B组合
LIST.permutations
#上面是排列，没有参数

合并、分段

zip LIST_A LIST_B
#只有subroutine, 没有method
#或者
LIST_A Z LIST_B
#两种形式一样，都以LIST_A的长度为准
#如果要以较长的那个为准，可以用
roundrobin LISTS
#短的list没有就空着，返回的list的sublist可能是层次不齐的

LIST.rotor(EXPR, :partial?)
#把list分段切，每几个元素一组
#如果EXPR是一个正整数，例如3，就3个元素一组分
#如果:partial，最后不足的部分也包括进来
#如果EXPR是a=>b，a是分组的单位，b如果为正表示跳过几个，b为负表示重叠几个
#如果有a=>b,c=>d,...就会每次调用一个规则，不断重复
#这个方法太好了

继承自Iterable类

ITERABLE.flat
ITERABLE.lazy
ITERABLE.race(BATCH?, DEGREE?)
#和hyper一样，不过返回的不一定是原顺序
ITERABLE.hyper(BATCH?, DEGREE?)
#实现并行处理，返回的iterable，仔call的方法就可以并行了