module List: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 -> 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 如果列表太短。Invalid_argument 如果 n 为负数。val nth_opt : 'a list -> int -> 'a option返回给定列表的第 n 个元素。第一个元素（列表的头部）位于位置 0。如果列表太短，则返回 None。
Invalid_argument 如果 n 为负数。val rev : 'a list -> 'a list列表反转。
val init : int -> (int -> 'a) -> 'a listinit len f 是 [f 0; f 1; ...; f (len-1)]，从左到右计算。
Invalid_argument 如果 len < 0。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 连接。这等效于 (List.rev l1) @ l2。
val concat : 'a list list -> 'a list连接一个列表列表。将参数的所有元素连接在一起（按相同顺序）以给出结果。非尾递归（参数的长度 + 最长子列表的长度）。
val flatten : 'a list list -> 'a list与 List.concat 相同。非尾递归（参数的长度 + 最长子列表的长度）。
val equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> boolequal eq [a1; ...; an] [b1; ..; bm] 当两个输入列表具有相同的长度时成立，并且对于相同位置的每对元素 ai、bi，我们都有 eq ai bi。
注意：即使列表长度不同，也可能调用 eq 函数。如果您知道您的相等函数代价高昂，您可能希望先检查 List.compare_lengths。
val compare : ('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 : ('a -> unit) -> 'a list -> unititer f [a1; ...; an] 依次将函数 f 应用于 [a1; ...; an]。它等效于 f a1; f a2; ...; f an。
val iteri : (int -> 'a -> unit) -> 'a list -> unit与 List.iter 相同，但函数应用于元素的索引作为第一个参数（从 0 开始计数），元素本身作为第二个参数。
val map : ('a -> 'b) -> 'a list -> 'b listmap f [a1; ...; an] 将函数 f 应用于 a1, ..., an，并使用 f 返回的结果构建列表 [f a1; ...; f an]。
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list与 List.map 相同，但函数应用于元素的索引作为第一个参数（从 0 开始计数），元素本身作为第二个参数。
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val filter_map : ('a -> 'b option) -> 'a list -> 'b listfilter_map f l 将 f 应用于 l 的每个元素，过滤掉 None 元素，并返回 Some 元素的参数列表。
val concat_map : ('a -> 'b list) -> 'a list -> 'b listconcat_map f l 给出与 List.concat (List.map f l) 相同的结果。尾递归。
val fold_left_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b listfold_left_map 是 fold_left 和 map 的组合，它将累加器传送到 f 的调用中。
val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'accfold_left f init [b1; ...; bn] 是 f (... (f (f init b1) b2) ...) bn。
val fold_right : ('a -> 'acc -> 'acc) -> 'a list -> 'acc -> 'accfold_right f [a1; ...; an] init 是 f a1 (f a2 (... (f an init) ...))。非尾递归。
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unititer2 f [a1; ...; an] [b1; ...; bn] 依次调用 f a1 b1; ...; f an bn。
Invalid_argument 如果确定两个列表具有不同的长度。val map2 : ('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 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('acc -> 'a -> 'b -> 'acc) -> '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 : ('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> 'acc -> 'accfold_right2 f [a1; ...; an] [b1; ...; bn] init 是 f a1 b1 (f a2 b2 (... (f an bn init) ...))。
Invalid_argument 如果确定两个列表具有不同的长度。非尾递归。val for_all : ('a -> bool) -> 'a list -> boolfor_all f [a1; ...; an] 检查列表的所有元素是否满足谓词 f。也就是说，它返回 (f a1) && (f a2) && ... && (f an) 对于非空列表，如果列表为空，则返回 true。
val exists : ('a -> bool) -> 'a list -> boolexists f [a1; ...; an] 检查列表中是否至少有一个元素满足谓词 f。也就是说，它返回 (f a1) || (f a2) || ... || (f an) 对于非空列表，如果列表为空，则返回 false。
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool与 List.for_all 相同，但对于两个参数的谓词。
Invalid_argument 如果确定两个列表具有不同的长度。val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool与 List.exists 相同，但对于两个参数的谓词。
Invalid_argument 如果确定两个列表具有不同的长度。val mem : 'a -> 'a list -> boolmem a set 当且仅当 a 等于 set 的元素时为真。
val memq : 'a -> 'a list -> bool与 List.mem 相同，但使用物理相等而不是结构相等来比较列表元素。
val find : ('a -> bool) -> 'a list -> 'afind f l 返回列表 l 中第一个满足谓词 f 的元素。
Not_found 如果列表 l 中没有满足 f 的值。val find_opt : ('a -> bool) -> 'a list -> 'a optionfind f l 返回列表 l 中第一个满足谓词 f 的元素。如果列表 l 中没有满足 f 的值，则返回 None。
val find_index : ('a -> bool) -> 'a list -> int optionfind_index f xs 返回 Some i，其中 i 是列表 xs 中第一个满足 f x 的元素的索引，如果有这样的元素。
如果不存在这样的元素，它将返回 None。
val find_map : ('a -> 'b option) -> 'a list -> 'b optionfind_map f l 按顺序将 f 应用于 l 的元素，并返回第一个形式为 Some v 的结果，如果不存在则返回 None。
val find_mapi : (int -> 'a -> 'b option) -> 'a list -> 'b option与 find_map 相同，但谓词以元素的索引作为第一个参数（从 0 开始计数），元素本身作为第二个参数。
val filter : ('a -> bool) -> 'a list -> 'a listfilter f l 返回列表 l 中满足谓词 f 的所有元素。输入列表中元素的顺序将保留。
val find_all : ('a -> bool) -> 'a list -> 'a listfind_all 是 List.filter 的另一个名称。
val filteri : (int -> 'a -> bool) -> 'a list -> 'a list与 List.filter 相同，但谓词以元素的索引作为第一个参数（从 0 开始计数），元素本身作为第二个参数。
val partition : ('a -> bool) -> 'a list -> 'a list * 'a listpartition f l 返回一对列表 (l1, l2)，其中 l1 是 l 中满足谓词 f 的所有元素的列表，而 l2 是 l 中不满足 f 的所有元素的列表。输入列表中元素的顺序将保留。
val partition_map : ('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 返回与键 a 关联的值，该值位于键值对列表 l 中。也就是说，如果 (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 返回与键 a 关联的值，该值位于键值对列表 l 中。也就是说，如果 (a,b) 是列表 l 中 a 的最左侧绑定，则 assoc_opt a [ ...; (a,b); ...] = Some b。如果列表 l 中没有与 a 关联的值，则返回 None。
val assq : 'a -> ('a * 'b) list -> 'b与 List.assoc 相同，但使用物理相等而不是结构相等来比较键。
val assq_opt : 'a -> ('a * 'b) list -> 'b option与 List.assoc_opt 相同，但使用物理相等而不是结构相等来比较键。
val mem_assoc : 'a -> ('a * 'b) list -> bool与 List.assoc 相同，但如果存在绑定，则简单地返回 true，如果对于给定键不存在绑定，则返回 false。
val mem_assq : 'a -> ('a * 'b) list -> bool与 List.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与 List.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 : ('a -> 'a -> int) -> 'a list -> 'a listval stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list与 List.sort 相同，但排序算法保证是稳定的（即比较相等的元素将保持其原始顺序）。
当前实现使用归并排序。它在恒定堆空间和对数栈空间内运行。
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list与 List.sort 或 List.stable_sort 相同，哪个在典型输入上更快。
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list与 List.sort 相同，但也会删除重复项。
val merge : ('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从序列创建列表。