函子 MoreLabels.Set.Make

module Make: 
functor (Ord : OrderedType) -> S 
    with type elt = Ord.t
     and type t = Set.Make(Ord).t

给定一个全序类型，构建集合结构实现的函子。

参数
Ord : OrderedType

集合

type elt

集合元素的类型。

type t

集合的类型。

val empty : t

空集。

val add : elt -> t -> t

add x s 返回一个包含 s 中所有元素以及 x 的集合。如果 x 已经存在于 s 中，则返回 s 本身（函数的结果在物理上等于 s）。

val singleton : elt -> t

singleton x 返回仅包含 x 的单元素集合。

val remove : elt -> t -> t

remove x s 返回一个包含 s 中所有元素（除了 x）的集合。如果 x 不在 s 中，则返回 s 本身（函数的结果在物理上等于 s）。

val union : t -> t -> t

集合并集。

val inter : t -> t -> t

集合交集。

val disjoint : t -> t -> bool

测试两个集合是否不相交。

val diff : t -> t -> t

集合差：diff s1 s2 包含 s1 中不在 s2 中的元素。

val cardinal : t -> int

返回集合中元素的数量。

元素

val elements : t -> elt list

返回给定集合的所有元素的列表。返回的列表根据排序 Ord.compare 按升序排序，其中 Ord 是传递给 MoreLabels.Set.Make 的参数。

val min_elt : t -> elt

返回给定集合中最小的元素（根据 Ord.compare 排序），如果集合为空则引发 Not_found。

val min_elt_opt : t -> elt option

返回给定集合中最小的元素（根据 Ord.compare 排序），如果集合为空则返回 None。

val max_elt : t -> elt

与 MoreLabels.Set.S.min_elt 相同，但返回给定集合中最大的元素。

val max_elt_opt : t -> elt option

与 MoreLabels.Set.S.min_elt_opt 相同，但返回给定集合中最大的元素。

val choose : t -> elt

返回给定集合中的一个元素，如果集合为空则引发 Not_found。选择哪个元素是不确定的，但对于相等的集合将选择相等的元素。

val choose_opt : t -> elt option

返回给定集合中的一个元素，如果集合为空则返回 None。选择哪个元素是不确定的，但对于相等的集合将选择相等的元素。

搜索

val find : elt -> t -> elt

find x s 返回 s 中等于 x 的元素（根据 Ord.compare），如果不存在这样的元素则引发 Not_found。

val find_opt : elt -> t -> elt option

find_opt x s 返回 s 中等于 x 的元素（根据 Ord.compare），如果不存在这样的元素则返回 None。

val find_first : f:(elt -> bool) ->
       t -> elt

find_first ~f s，其中 f 是一个单调递增函数，返回 s 中满足 f e 的最小元素 e，如果不存在这样的元素则引发 Not_found。

例如，find_first (fun e -> Ord.compare e x >= 0) s 将返回 s 中第一个满足 Ord.compare e x >= 0 的元素 e（直观地：e >= x），如果 x 大于 s 中的任何元素则引发 Not_found。

val find_first_opt : f:(elt -> bool) ->
       t -> elt option

find_first_opt ~f s，其中 f 是一个单调递增函数，返回一个包含 s 中满足 f e 的最小元素 e 的选项，如果不存在这样的元素则返回 None。

val find_last : f:(elt -> bool) ->
       t -> elt

find_last ~f s，其中 f 是一个单调递减函数，返回 s 中满足 f e 的最大元素 e，如果不存在这样的元素则引发 Not_found。

val find_last_opt : f:(elt -> bool) ->
       t -> elt option

find_last_opt ~f s，其中 f 是一个单调递减函数，返回一个包含 s 中满足 f e 的最大元素 e 的选项，如果不存在这样的元素则返回 None。

遍历

val iter : f:(elt -> unit) -> t -> unit

iter ~f s 依次将 f 应用于 s 中的所有元素。 s 的元素以元素类型上的排序顺序递增的顺序呈现给 f。

val fold : f:(elt -> 'acc -> 'acc) ->
       t -> init:'acc -> 'acc

fold ~f s init 计算 (f xN ... (f x2 (f x1 init))...)，其中 x1 ... xN 是 s 中的元素，按升序排列。

转换

val map : f:(elt -> elt) ->
       t -> t

map ~f s 是一个集合，其元素为 f a0、f a1… f
          aN，其中 a0、a1…aN 是 s 中的元素。

元素以元素类型上的排序顺序递增的顺序传递给 f。

如果 s 中没有元素被 f 更改，则返回 s 本身。（如果 f 的每个输出在物理上等于其输入，则返回的集合在物理上等于 s。）

val filter : f:(elt -> bool) -> t -> t

filter ~f s 返回 s 中所有满足谓词 f 的元素的集合。如果 f 满足 s 中的每个元素，则返回 s 本身（函数的结果在物理上等于 s）。

val filter_map : f:(elt -> elt option) ->
       t -> t

filter_map ~f s 返回所有 v 的集合，使得对于 s 的某个元素 x，f x = Some v。

例如，

filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s

是 s 中偶数元素的一半的集合。

如果 s 中没有元素被 f 更改或删除（如果对于每个元素 x，f x = Some x），则返回 s 本身：函数的结果在物理上等于 s。

val partition : f:(elt -> bool) ->
       t -> t * t

partition ~f s 返回一个集合对 (s1, s2)，其中 s1 是 s 中所有满足谓词 f 的元素的集合，s2 是 s 中所有不满足 f 的元素的集合。

val split : elt ->
       t -> t * bool * t

split x s 返回一个三元组 (l, present, r)，其中 l 是 s 中严格小于 x 的元素的集合；r 是 s 中严格大于 x 的元素的集合；present 如果 s 不包含等于 x 的元素则为 false，或者如果 s 包含等于 x 的元素则为 true。

谓词和比较

val is_empty : t -> bool

测试集合是否为空。

val mem : elt -> t -> bool

mem x s 测试 x 是否属于集合 s。

val equal : t -> t -> bool

equal s1 s2 测试集合 s1 和 s2 是否相等，即包含相等的元素。

val compare : t -> t -> int

集合之间的全序关系。可以用作执行集合的集合的排序函数。

val subset : t -> t -> bool

subset s1 s2 测试集合 s1 是否是集合 s2 的子集。

val for_all : f:(elt -> bool) -> t -> bool

for_all ~f s 检查集合中的所有元素是否满足谓词 f。

val exists : f:(elt -> bool) -> t -> bool

exists ~f s 检查集合中是否存在至少一个元素满足谓词 f。

转换

val to_list : t -> elt list

to_list s 等于 MoreLabels.Set.S.elements s。

val of_list : elt list -> t

of_list l 从元素列表创建集合。这通常比对列表进行 add 折叠更有效率，除了可能对于具有许多重复元素的列表。

val to_seq_from : elt ->
       t -> elt Seq.t

to_seq_from x s 按升序迭代 s 的元素的一个子集，从 x 或更高版本开始。

val to_seq : t -> elt Seq.t

按升序迭代整个集合

val to_rev_seq : t -> elt Seq.t

按降序迭代整个集合

val add_seq : elt Seq.t -> t -> t

按顺序将给定元素添加到集合中。

val of_seq : elt Seq.t -> t

根据给定的绑定构建一个集合