module ListLabels: ListLabelstype'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 如果列表太短。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 : len:int -> f:(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 连接起来。这等同于 (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 的第一个元素。
Not_found 如果列表 l 中没有满足 f 的值。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 返回键 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与 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从序列创建列表。