函子 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 中最低的元素 e，使得 f e，如果不存在此類元素，則引發 Not_found 異常。

例如，find_first (fun e -> Ord.compare e x >= 0) s 會傳回 s 中第一個元素 e，其中 Ord.compare e x >= 0（直觀地說：e >= x），如果 x 大於 s 的任何元素，則引發 Not_found 異常。

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

find_first_opt ~f s，其中 f 是一個單調遞增的函式，傳回一個包含 s 中最低元素 e 的選項，使得 f e，如果不存在此類元素，則傳回 None。

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

find_last ~f s，其中 f 是一個單調遞減的函式，傳回 s 中最高的元素 e，使得 f e，如果不存在此類元素，則引發 Not_found 異常。

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

find_last_opt ~f s，其中 f 是一個單調遞減的函式，傳回一個包含 s 中最高元素 e 的選項，使得 f 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 的元素的集合；如果 s 沒有包含等於 x 的元素，則 present 為 false，如果 s 包含等於 x 的元素，則 present 為 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 依遞增順序從 x 或以上迭代 s 的元素子集。

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

從給定的綁定建立集合