module Make:
函子，根據給定的全序型別，建立映射結構的實作。
| 參數 |
|
type
映射鍵的型別。
type !+'a t
從型別 key 到型別 'a 的映射型別。
val empty : 'a t空的映射。
val add : key -> 'a -> 'a t -> 'a tadd key data m 傳回一個映射，其中包含與 m 相同的綁定，加上 key 到 data 的綁定。如果 key 已經在 m 中綁定到一個與 data 物理相等的數值，則 m 會保持不變（此函式的結果會與 m 物理相等）。否則，key 在 m 中的先前綁定會消失。
val add_to_list : key -> 'a -> 'a list t -> 'a list tadd_to_list key data m 是 m，其中 key 映射到 l，使得如果 key 在 m 中有綁定，則 l 為 data :: Map.find key m，否則為 [v]。
val update : key -> ('a option -> 'a option) -> 'a t -> 'a tupdate 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 tsingleton x y 傳回一個單元素的映射，其中包含 x 的 y 綁定。
val remove : key -> 'a t -> 'a tremove x m 傳回一個映射，其中包含與 m 相同的綁定，除了 x 在傳回的映射中未綁定。如果 x 不在 m 中，則 m 會保持不變（此函式的結果會與 m 物理相等）。
val merge : (key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c tmerge 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 : (key -> 'a -> 'a -> 'a option) ->
'a t -> 'a t -> 'a tunion f m1 m2 計算一個映射，其鍵是 m1 和 m2 鍵的子集。當相同的綁定在兩個引數中都定義時，會使用函式 f 來組合它們。這是 merge 的特例：union f m1 m2 等同於 merge f' m1 m2，其中
f' _key None None = Nonef' _key (Some v) None = Some vf' _key None (Some v) = Some vf' key (Some v1) (Some v2) = f key v1 v2val cardinal : 'a t -> int傳回映射的綁定數量。
val bindings : 'a t -> (key * 'a) list傳回指定映射的所有綁定清單。傳回的清單會根據鍵的排序以遞增順序排序，排序方式依照 Ord.compare，其中 Ord 是給 Map.Make 的引數。
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與 Map.S.min_binding 相同，但傳回指定映射中具有最大鍵的綁定。
val max_binding_opt : 'a t -> (key * 'a) option與 Map.S.min_binding_opt 相同，但傳回指定映射中具有最大鍵的綁定。
val choose : 'a t -> key * 'a傳回指定映射的一個綁定，如果映射為空，則引發 Not_found 例外。選擇哪個綁定是未指定的，但對於相等的映射會選擇相等的綁定。
val choose_opt : 'a t -> (key * 'a) option傳回指定映射的一個綁定，如果映射為空，則傳回 None。選擇哪個綁定是未指定的，但對於相等的映射會選擇相等的綁定。
val find : key -> 'a t -> 'afind x m 傳回 x 在 m 中的當前值，如果沒有 x 的綁定，則引發 Not_found 例外。
val find_opt : key -> 'a t -> 'a optionfind_opt x m 如果 x 在 m 中的當前值為 v，則傳回 Some v，如果沒有 x 的綁定，則傳回 None。
val find_first : (key -> bool) -> 'a t -> key * 'afind_first f m，其中 f 是一個單調遞增函式，傳回 m 中具有最小鍵 k 的綁定，使得 f 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 : (key -> bool) -> 'a t -> (key * 'a) optionfind_first_opt f m，其中 f 是一個單調遞增函式，傳回一個選項，其中包含 m 中具有最小鍵 k 的綁定，使得 f k，如果不存在此類鍵，則傳回 None。
val find_last : (key -> bool) -> 'a t -> key * 'afind_last f m，其中 f 是一個單調遞減函式，傳回 m 中具有最大鍵 k 的綁定，使得 f k，如果不存在此類鍵，則引發 Not_found 例外。
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) optionfind_last_opt f m，其中 f 是一個單調遞減函式，傳回一個選項，其中包含 m 中具有最大鍵 k 的綁定，使得 f k，如果不存在此類鍵，則傳回 None。
val iter : (key -> 'a -> unit) -> 'a t -> unititer f m 將 f 套用至映射 m 中的所有綁定。f 接收鍵作為第一個引數，關聯的值作為第二個引數。綁定會依照鍵型別排序的遞增順序傳遞至 f。
val fold : (key -> 'a -> 'acc -> 'acc) -> 'a t -> 'acc -> 'accfold f m init 計算 (f kN dN ... (f k1 d1 init)...)，其中 k1 ... kN 是 m 中所有綁定的鍵（依照遞增順序），而 d1 ... dN 是關聯的資料。
val map : ('a -> 'b) -> 'a t -> 'b tmap f m 傳回一個與 m 具有相同域的映射，其中 m 的所有綁定的關聯值 a 已被 f 套用至 a 的結果所取代。綁定會依照鍵型別排序的遞增順序傳遞至 f。
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t與 Map.S.map 相同，但函式會接收映射中每個綁定的鍵和關聯值作為引數。
val filter : (key -> 'a -> bool) -> 'a t -> 'a tfilter f m 傳回一個映射，其中包含 m 中滿足謂詞 p 的所有綁定。如果 m 中的每個綁定都滿足 f，則 m 會保持不變（此函式的結果會與 m 物理相等）
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b tfilter_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 : (key -> 'a -> bool) -> 'a t -> 'a t * 'a tpartition f m 傳回一對映射 (m1, m2)，其中 m1 包含 m 中滿足謂詞 f 的所有綁定，而 m2 則是包含 m 中不滿足 f 的所有綁定的映射。
val split : key -> 'a t -> 'a t * 'a option * 'a tsplit x m 傳回一個三元組 (l, data, r)，其中 l 是一個 map，包含 m 中所有鍵嚴格小於 x 的綁定；r 是一個 map，包含 m 中所有鍵嚴格大於 x 的綁定；如果 m 沒有 x 的綁定，則 data 為 None，否則如果 m 將 v 綁定到 x，則 data 為 Some v。
val is_empty : 'a t -> bool測試一個 map 是否為空。
val mem : key -> 'a t -> boolmem x m 如果 m 包含 x 的綁定，則返回 true，否則返回 false。
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> boolequal cmp m1 m2 測試 map m1 和 m2 是否相等，也就是說，它們是否包含相等的鍵，並且將這些鍵與相同的資料關聯。cmp 是用於比較與鍵相關聯的資料是否相等的相等謂詞。
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> intmap 之間的總排序。第一個參數是用於比較兩個 map 中相同鍵所關聯資料的總排序。
val for_all : (key -> 'a -> bool) -> 'a t -> boolfor_all f m 檢查 map 的所有綁定是否都滿足謂詞 f。
val exists : (key -> 'a -> bool) -> 'a t -> boolexists f m 檢查 map 中是否至少有一個綁定滿足謂詞 f。
val to_list : 'a t -> (key * 'a) listto_list m 等同於 Map.S.bindings m。
val of_list : (key * 'a) list -> 'a tof_list bs 按照列表順序將 bs 的綁定添加到空 map（如果一個鍵在 bs 中被綁定兩次，則最後一個綁定會覆蓋之前的綁定）。
val to_seq : 'a t -> (key * 'a) Seq.t以鍵的遞增順序迭代整個 map。
val to_rev_seq : 'a t -> (key * 'a) Seq.t以鍵的遞減順序迭代整個 map。
val to_seq_from : key -> 'a t -> (key * 'a) Seq.tto_seq_from k m 從鍵 k 或以上的鍵開始，以鍵的遞增順序迭代 m 的綁定子集。
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t依序將給定的綁定添加到 map。
val of_seq : (key * 'a) Seq.t -> 'a t從給定的綁定建立一個 map。