module List: Listtype'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 是满足谓词 f 的 l 的所有元素的列表，而 l2 是不满足 f 的 l 的所有元素的列表。输入列表中元素的顺序得以保留。
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从序列中创建列表。