module ListLabels:sig..end
列表操作。
一些函数被标记为非尾递归。尾递归函数使用恒定的栈空间，而非尾递归函数使用与列表参数长度成正比的栈空间，对于非常长的列表，这可能是一个问题。当函数接受多个列表参数时，括号中显示了给出栈使用情况（以某个未指定的常量单位表示）的近似公式。
如果您的列表不超过约 10000 个元素，通常可以忽略上述考虑因素。
此模块的带标签版本可以按照StdLabels模块中描述的方式使用。
type'at ='a list=
| |
[] |
| |
(::) of |
列表类型的一个别名。
val length : 'a list -> int返回给定列表的长度（元素数量）。
val compare_lengths : 'a list -> 'b list -> int比较两个列表的长度。compare_lengths l1 l2 等价于 compare (length l1) (length l2)，除了计算在到达最短列表的末尾后停止。
val compare_length_with : 'a list -> len:int -> int将列表的长度与整数进行比较。compare_length_with l len 等价于 compare (length l) len，除了计算最多在列表上迭代 len 次后停止。
val is_empty : 'a list -> boolis_empty l 当且仅当 l 没有元素时为真。它等价于 compare_length_with l 0 = 0。
val cons : 'a -> 'a list -> 'a listcons x xs 等于 x :: xs
val hd : 'a list -> 'a返回给定列表的第一个元素。
Failure。val tl : 'a list -> 'a list返回给定列表，但不包含其第一个元素。
Failure。val nth : 'a list -> int -> 'a返回给定列表的第 n 个元素。第一个元素（列表头部）位于位置 0。
Failure。n 为负，则引发 Invalid_argument。val nth_opt : 'a list -> int -> 'a option返回给定列表的第 n 个元素。第一个元素（列表头部）位于位置 0。如果列表太短，则返回 None。
n 为负，则引发 Invalid_argument。val rev : 'a list -> 'a list列表反转。
val init : len:int -> f:(int -> 'a) -> 'a listinit ~len ~f 等于 [f 0; f 1; ...; f (len-1)]，从左到右计算。
len < 0，则引发 Invalid_argument。val append : 'a list -> 'a list -> 'a listappend l0 l1 将 l1 附加到 l0。与中缀运算符 @ 相同的功能。
val rev_append : 'a list -> 'a list -> 'a listrev_append l1 l2 反转 l1 并将其与 l2 连接起来。这等价于 (ListLabels.rev l1) @ l2。
val concat : 'a list list -> 'a list连接列表的列表。参数的所有元素都连接在一起（按相同的顺序）以给出结果。非尾递归（参数的长度 + 最长子列表的长度）。
val flatten : 'a list list -> 'a list与 ListLabels.concat 相同。非尾递归（参数的长度 + 最长子列表的长度）。
val equal : eq:('a -> 'a -> bool) -> 'a list -> 'a list -> boolequal eq [a1; ...; an] [b1; ..; bm] 当两个输入列表具有相同的长度时成立，并且对于每个位于相同位置的元素对 ai、bi，我们都有 eq ai bi。
注意：即使列表长度不同，也可能会调用 eq 函数。如果您知道您的相等函数代价很高，您可能希望先检查 ListLabels.compare_lengths。
val compare : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> intcompare cmp [a1; ...; an] [b1; ...; bm] 对两个输入列表执行字典序比较，使用与 compare 相同的 'a -> 'a -> int 接口
a1 :: l1 小于 a2 :: l2（负结果），如果 a1 小于 a2，或者如果它们相等（0 结果）并且 l1 小于 l2[] 严格小于非空列表注意：即使列表长度不同，也会调用 cmp 函数。
val iter : f:('a -> unit) -> 'a list -> unititer ~f [a1; ...; an] 依次将函数 f 应用于 [a1; ...; an]。它等价于 f a1; f a2; ...; f an。
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit与 ListLabels.iter 相同，但该函数将元素的索引作为第一个参数（从 0 开始计数），并将元素本身作为第二个参数。
val map : f:('a -> 'b) -> 'a list -> 'b listmap ~f [a1; ...; an] 将函数 f 应用于 a1, ..., an，并使用 f 返回的结果构建列表 [f a1; ...; f an]。
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list与 ListLabels.map 相同，但该函数将元素的索引作为第一个参数（从 0 开始计数），并将元素本身作为第二个参数。
val rev_map : f:('a -> 'b) -> 'a list -> 'b listrev_map ~f l 给出的结果与 ListLabels.rev (ListLabels.map f l) 相同，但效率更高。
val filter_map : f:('a -> 'b option) -> 'a list -> 'b listfilter_map ~f l 将 f 应用于 l 的每个元素，过滤掉 None 元素，并返回 Some 元素的参数列表。
val concat_map : f:('a -> 'b list) -> 'a list -> 'b listconcat_map ~f l 给出的结果与 ListLabels.concat (ListLabels.map f l) 相同。尾递归。
val fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b listfold_left_map 是 fold_left 和 map 的组合，它将累加器贯穿 f 的调用。
val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'accfold_left ~f ~init [b1; ...; bn] 等于 f (... (f (f init b1) b2) ...) bn。
val fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'accfold_right ~f [a1; ...; an] ~init 等于 f a1 (f a2 (... (f an init) ...))。非尾递归。
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unititer2 ~f [a1; ...; an] [b1; ...; bn] 依次调用 f a1 b1; ...; f an bn。
Invalid_argument。val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listmap2 ~f [a1; ...; an] [b1; ...; bn] 等于 [f a1 b1; ...; f an bn]。
Invalid_argument。val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listrev_map2 ~f l1 l2 给出的结果与 ListLabels.rev (ListLabels.map2 f l1 l2) 相同，但效率更高。
val fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'accfold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] 等于 f (... (f (f init a1 b1) a2 b2) ...) an bn。
Invalid_argument。val fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'accfold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init 等于 f a1 b1 (f a2 b2 (... (f an bn init) ...))。
Invalid_argument。非尾递归。val for_all : f:('a -> bool) -> 'a list -> boolfor_all ~f [a1; ...; an] 检查列表的所有元素是否都满足谓词 f。也就是说，它返回 (f a1) && (f a2) && ... && (f an)（对于非空列表）以及 true（如果列表为空）。
val exists : f:('a -> bool) -> 'a list -> boolexists ~f [a1; ...; an] 检查列表中是否至少有一个元素满足谓词 f。也就是说，它返回 (f a1) || (f a2) || ... || (f an)（对于非空列表）以及 false（如果列表为空）。
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool与 ListLabels.for_all 相同，但适用于二元谓词。
Invalid_argument。val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool与 ListLabels.exists 相同，但适用于二元谓词。
Invalid_argument。val mem : 'a -> set:'a list -> boolmem a ~set 当且仅当 a 等于 set 的某个元素时为真。
val memq : 'a -> set:'a list -> bool与 ListLabels.mem 相同，但使用物理相等而不是结构相等来比较列表元素。
val find : f:('a -> bool) -> 'a list -> 'afind ~f l 返回列表 l 中满足谓词 f 的第一个元素。
l 中没有满足 f 的值，则引发 Not_found。val find_opt : f:('a -> bool) -> 'a list -> 'a optionfind ~f l 返回列表 l 中满足谓词 f 的第一个元素。如果列表 l 中没有满足 f 的值，则返回 None。
val find_index : f:('a -> bool) -> 'a list -> int optionfind_index ~f xs 返回 Some i，其中 i 是列表 xs 中第一个满足 f x 的元素的索引（如果存在这样的元素）。
如果不存在这样的元素，则返回 None。
val find_map : f:('a -> 'b option) -> 'a list -> 'b optionfind_map ~f l 按顺序将 f 应用于 l 的元素，并返回第一个形如 Some v 的结果，或者如果不存在这样的结果，则返回 None。
val find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option与 find_map 相同，但谓词将元素的索引作为第一个参数（从 0 开始计数），并将元素本身作为第二个参数。
val filter : f:('a -> bool) -> 'a list -> 'a listfilter ~f l 返回列表 l 中满足谓词 f 的所有元素。输入列表中元素的顺序保持不变。
val find_all : f:('a -> bool) -> 'a list -> 'a listfind_all 是 ListLabels.filter 的另一个名称。
val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list与 ListLabels.filter 相同，但谓词将元素的索引作为第一个参数（从 0 开始计数），并将元素本身作为第二个参数。
val partition : f:('a -> bool) -> 'a list -> 'a list * 'a listpartition ~f l 返回一个包含两个列表的元组 (l1, l2)，其中 l1 包含列表 l 中所有满足谓词 f 的元素，l2 包含列表 l 中所有不满足谓词 f 的元素。输入列表中的元素顺序保持不变。
val partition_map : f:('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listpartition_map f l 返回一个包含两个列表的元组 (l1, l2)，使得对于输入列表 l 中的每个元素 x
f x 等于 Left y1，则 y1 位于 l1 中，并且f x 等于 Right y2，则 y2 位于 l2 中。输出元素在 l1 和 l2 中的相对顺序与它们在 l 中对应的输入元素的相对顺序相同。
特别是，partition_map (fun x -> if f x then Left x else Right x) l 等价于 partition f l。
val assoc : 'a -> ('a * 'b) list -> 'bassoc a l 返回在键值对列表 l 中与键 a 关联的值。也就是说，如果 (a,b) 是列表 l 中 a 最左边的绑定，则 assoc a [ ...; (a,b); ...] = b。
Not_found 异常，如果列表 l 中没有与 a 关联的值。val assoc_opt : 'a -> ('a * 'b) list -> 'b optionassoc_opt a l 返回在键值对列表 l 中与键 a 关联的值。也就是说，如果 (a,b) 是列表 l 中 a 最左边的绑定，则 assoc_opt a [ ...; (a,b); ...] = Some b。如果列表 l 中没有与 a 关联的值，则返回 None。
val assq : 'a -> ('a * 'b) list -> 'b与 ListLabels.assoc 相同，但使用物理相等性而不是结构相等性来比较键。
val assq_opt : 'a -> ('a * 'b) list -> 'b option与 ListLabels.assoc_opt 相同，但使用物理相等性而不是结构相等性来比较键。
val mem_assoc : 'a -> map:('a * 'b) list -> bool与 ListLabels.assoc 相同，但如果存在绑定则简单地返回 true，如果对于给定键不存在绑定则返回 false。
val mem_assq : 'a -> map:('a * 'b) list -> bool与 ListLabels.mem_assoc 相同，但使用物理相等性而不是结构相等性来比较键。
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) listremove_assoc a l 返回键值对列表 l，其中删除了第一个键为 a 的键值对（如果存在）。不是尾递归的。
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list与 ListLabels.remove_assoc 相同，但使用物理相等性而不是结构相等性来比较键。不是尾递归的。
val split : ('a * 'b) list -> 'a list * 'b list将键值对列表转换为两个列表的元组：split [(a1,b1); ...; (an,bn)] 等于 ([a1; ...; an], [b1; ...; bn])。不是尾递归的。
val combine : 'a list -> 'b list -> ('a * 'b) list将两个列表的元组转换为键值对列表：combine [a1; ...; an] [b1; ...; bn] 等于 [(a1,b1); ...; (an,bn)]。
Invalid_argument 异常，如果两个列表的长度不同。不是尾递归的。val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list根据比较函数对列表进行升序排序。比较函数必须在其参数相等时返回 0，第一个参数大于第二个参数时返回正整数，第一个参数小于第二个参数时返回负整数（有关完整规范，请参阅 Array.sort）。例如，compare 是一个合适的比较函数。生成的列表按升序排序。 ListLabels.sort 保证在恒定的堆空间（除了结果列表的大小）和对数栈空间内运行。
当前的实现使用归并排序。它在恒定的堆空间和对数栈空间内运行。
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list与 ListLabels.sort 相同，但排序算法保证是稳定的（即，比较相等的元素保持其原始顺序）。
当前的实现使用归并排序。它在恒定的堆空间和对数栈空间内运行。
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list与 ListLabels.sort 或 ListLabels.stable_sort 相同，选择在典型输入上速度更快的算法。
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list与 ListLabels.sort 相同，但还会删除重复项。
val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list合并两个列表：假设 l1 和 l2 根据比较函数 cmp 进行排序，merge ~cmp l1 l2 将返回一个包含 l1 和 l2 所有元素的排序列表。如果多个元素比较相等，则 l1 中的元素将在 l2 中的元素之前。不是尾递归的（参数长度的总和）。
val to_seq : 'a list -> 'a Seq.t遍历列表。
val of_seq : 'a Seq.t -> 'a list从序列创建列表。