函子 MoreLabels.Map.Make

module Make: 
functor (Ord : OrderedType) -> S 
    with type key = Ord.t
     and type 'a t = 'a Map.Make(Ord).t

函子用於建構給定一個完全排序型別的映射結構實作。

參數
Ord : OrderedType

映射 (Maps)

type key

映射鍵的型別。

type !+'a t

從型別 key 到型別 'a 的映射型別。

val empty : 'a t

空的映射。

val add : key:key ->
       data:'a -> 'a t -> 'a t

add ~key ~data m 傳回一個包含與 m 相同綁定，加上 key 到 data 的綁定的映射。 如果 key 已經在 m 中綁定到一個物理上等於 data 的值，則 m 不會變更地傳回（函數的結果在物理上會等於 m）。 否則，key 在 m 中的先前綁定會消失。

val add_to_list : key:key ->
       data:'a -> 'a list t -> 'a list t

add_to_list ~key ~data m 是 m，其中 key 映射到 l，使得如果 key 在 m 中有綁定，則 l 為 data :: Map.find key m，否則為 [v]。

val update : key:key ->
       f:('a option -> 'a option) -> 'a t -> 'a t

update ~key ~f m 傳回一個包含與 m 相同綁定的映射，除了 key 的綁定之外。根據 y 的值，其中 y 是 f (find_opt key m)，key 的綁定會被新增、移除或更新。如果 y 是 None，則會移除該綁定（如果存在）；否則，如果 y 是 Some z，則 key 會在結果映射中與 z 關聯。如果 key 已經在 m 中綁定到一個物理上等於 z 的值，則 m 不會變更地傳回（函數的結果在物理上會等於 m）。

val singleton : key -> 'a -> 'a t

singleton x y 傳回一個單元素的映射，其中包含 x 的綁定 y。

val remove : key -> 'a t -> 'a t

remove x m 傳回一個包含與 m 相同綁定的映射，除了在傳回的映射中 x 是未綁定的。如果 x 不在 m 中，則 m 不會變更地傳回（函數的結果在物理上會等於 m）。

val merge : f:(key -> 'a option -> 'b option -> 'c option) ->
       'a t -> 'b t -> 'c t

merge ~f m1 m2 計算一個映射，其鍵是 m1 和 m2 的鍵的子集。每個此類綁定的存在及其對應的值，都由函數 f 決定。就 find_opt 操作而言，對於任何鍵 x，我們有 find_opt x (merge f m1 m2) = f x (find_opt x m1) (find_opt x m2)，前提是 f x None None = None。

val union : f:(key -> 'a -> 'a -> 'a option) ->
       'a t -> 'a t -> 'a t

union ~f m1 m2 計算一個映射，其鍵是 m1 和 m2 的鍵的子集。當兩個引數中定義了相同的綁定時，會使用函數 f 來組合它們。這是 merge 的一種特殊情況：union f m1 m2 等效於 merge f' m1 m2，其中

  • f' _key None None = None
  • f' _key (Some v) None = Some v
  • f' _key None (Some v) = Some v
  • f' key (Some v1) (Some v2) = f key v1 v2
val cardinal : 'a t -> int

傳回映射的綁定數量。

綁定 (Bindings)

val bindings : 'a t -> (key * 'a) list

傳回給定映射的所有綁定清單。傳回的清單會依據鍵的順序，根據 MoreLabels.Map.Make 的引數 Ord 給定的順序 Ord.compare 遞增排序。

val min_binding : 'a t -> key * 'a

傳回給定映射中鍵最小的綁定（根據 Ord.compare 順序），如果映射為空則會引發 Not_found 錯誤。

val min_binding_opt : 'a t -> (key * 'a) option

傳回給定映射中鍵最小的綁定（根據 Ord.compare 順序），如果映射為空則傳回 None。

val max_binding : 'a t -> key * 'a

與 MoreLabels.Map.S.min_binding 相同，但傳回給定映射中鍵最大的綁定。

val max_binding_opt : 'a t -> (key * 'a) option

與 MoreLabels.Map.S.min_binding_opt 相同，但傳回給定映射中鍵最大的綁定。

val choose : 'a t -> key * 'a

傳回給定映射的一個綁定，如果映射為空則會引發 Not_found 錯誤。選擇哪個綁定是不指定的，但對於相等的映射，將選擇相等的綁定。

val choose_opt : 'a t -> (key * 'a) option

傳回給定映射的一個綁定，如果映射為空則傳回 None。選擇哪個綁定是不指定的，但對於相等的映射，將選擇相等的綁定。

搜尋 (Searching)

val find : key -> 'a t -> 'a

find x m 傳回 m 中 x 的目前值，如果不存在 x 的綁定則會引發 Not_found 錯誤。

val find_opt : key -> 'a t -> 'a option

find_opt x m 如果 m 中 x 的目前值是 v，則傳回 Some v，如果不存在 x 的綁定，則傳回 None。

val find_first : f:(key -> bool) ->
       'a t -> key * 'a

find_first ~f m，其中 f 是一個單調遞增的函數，傳回 m 中鍵最低且滿足 f k 的綁定 k，如果不存在這樣的鍵則會引發 Not_found 錯誤。

例如，find_first (fun k -> Ord.compare k x >= 0) m 會傳回 m 的第一個綁定 k, v，其中 Ord.compare k x >= 0（直覺上：k >= x），如果 x 大於 m 的任何元素，則會引發 Not_found 錯誤。

val find_first_opt : f:(key -> bool) ->
       'a t -> (key * 'a) option

find_first_opt ~f m，其中 f 是一個單調遞增的函數，傳回一個包含 m 中鍵最低且滿足 f k 的綁定 k 的選項，如果不存在這樣的鍵則傳回 None。

val find_last : f:(key -> bool) ->
       'a t -> key * 'a

find_last ~f m，其中 f 是一個單調遞減的函數，傳回 m 中鍵最高且滿足 f k 的綁定 k，如果不存在這樣的鍵則會引發 Not_found 錯誤。

val find_last_opt : f:(key -> bool) ->
       'a t -> (key * 'a) option

find_last_opt ~f m，其中 f 是一個單調遞減的函數，傳回一個包含 m 中鍵最高且滿足 f k 的綁定 k 的選項，如果不存在這樣的鍵則傳回 None。

遍歷 (Traversing)

val iter : f:(key:key -> data:'a -> unit) ->
       'a t -> unit

iter ~f m 將 f 套用至映射 m 中的所有綁定。f 接收鍵作為第一個引數，並將關聯的值作為第二個引數。綁定會根據鍵型別的順序遞增地傳遞給 f。

val fold : f:(key:key -> data:'a -> 'acc -> 'acc) ->
       'a t -> init:'acc -> 'acc

fold ~f m ~init 計算 (f kN dN ... (f k1 d1 init)...)，其中 k1 ... kN 是 m 中所有綁定的鍵（依遞增順序），而 d1 ... dN 是關聯的資料。

轉換 (Transforming)

val map : f:('a -> 'b) -> 'a t -> 'b t

map ~f m 傳回一個與 m 具有相同域的映射，其中 m 的所有綁定的關聯值 a 都已被替換為將 f 套用至 a 的結果。綁定會根據鍵型別的順序遞增地傳遞給 f。

val mapi : f:(key -> 'a -> 'b) ->
       'a t -> 'b t

與 MoreLabels.Map.S.map 相同，但此函數接收映射的每個綁定的鍵和關聯的值作為引數。

val filter : f:(key -> 'a -> bool) ->
       'a t -> 'a t

filter ~f m 傳回具有 m 中所有滿足謂詞 p 的綁定的映射。如果 m 中的每個綁定都滿足 f，則 m 不會變更地傳回（函數的結果在物理上會等於 m）

val filter_map : f:(key -> 'a -> 'b option) ->
       'a t -> 'b t

filter_map ~f m 將函數 f 套用至 m 的每個綁定，並從結果建構一個映射。對於輸入映射中的每個綁定 (k, v)

  • 如果 f k v 是 None，則 k 不會在結果中。
  • 如果 f k v 是 Some v'，則綁定 (k, v') 會在輸出映射中。

例如，下列關於值為清單的映射的函數

          filter_map
            (fun _k li -> match li with [] -> None | _::tl -> Some tl)
            m

會捨棄 m 中所有值為空清單的綁定，並彈出每個非空值的第一個元素。

val partition : f:(key -> 'a -> bool) ->
       'a t -> 'a t * 'a t

partition ~f m 返回一對映射 (m1, m2)，其中 m1 包含 m 中所有滿足謂詞 f 的綁定，而 m2 則包含 m 中所有不滿足 f 的綁定。

val split : key ->
       'a t ->
       'a t * 'a option * 'a t

split x m 返回一個三元組 (l, data, r)，其中 l 是包含 m 中所有鍵嚴格小於 x 的綁定的映射；r 是包含 m 中所有鍵嚴格大於 x 的綁定的映射；如果 m 不包含 x 的綁定，則 data 為 None，如果 m 將 v 綁定到 x，則 data 為 Some v。

謂詞與比較 (Predicates and comparisons)

val is_empty : 'a t -> bool

測試映射是否為空。

val mem : key -> 'a t -> bool

mem x m 如果 m 包含 x 的綁定，則返回 true，否則返回 false。

val equal : cmp:('a -> 'a -> bool) ->
       'a t -> 'a t -> bool

equal ~cmp m1 m2 測試映射 m1 和 m2 是否相等，即是否包含相等的鍵並將它們與相等的數據關聯。cmp 是用於比較與鍵關聯的數據的相等謂詞。

val compare : cmp:('a -> 'a -> int) ->
       'a t -> 'a t -> int

映射之間的總排序。第一個參數是用於比較兩個映射中具有相等鍵的數據的總排序。

val for_all : f:(key -> 'a -> bool) -> 'a t -> bool

for_all ~f m 檢查映射的所有綁定是否都滿足謂詞 f。

val exists : f:(key -> 'a -> bool) -> 'a t -> bool

exists ~f m 檢查映射中是否至少有一個綁定滿足謂詞 f。

轉換 (Converting)

val to_list : 'a t -> (key * 'a) list

to_list m 為 MoreLabels.Map.S.bindings m。

val of_list : (key * 'a) list -> 'a t

of_list bs 將 bs 的綁定以列表順序添加到空映射（如果一個鍵在 bs 中綁定兩次，則最後一個綁定生效）。

val to_seq : 'a t -> (key * 'a) Seq.t

依鍵的升序迭代整個映射。

val to_rev_seq : 'a t -> (key * 'a) Seq.t

依鍵的降序迭代整個映射。

val to_seq_from : key ->
       'a t -> (key * 'a) Seq.t

to_seq_from k m 從鍵 k 或以上開始，依鍵的升序迭代 m 的綁定子集。

val add_seq : (key * 'a) Seq.t ->
       'a t -> 'a t

依順序將給定的綁定添加到映射。

val of_seq : (key * 'a) Seq.t -> 'a t

從給定的綁定建立映射。