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）。否则，m 中 key 的先前绑定将消失。
val add_to_list : key -> 'a -> 'a list t -> 'a list tadd_to_list key data m 等于 m，其中 key 映射到 l，使得 l 为 data :: Map.find key m（如果 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 返回一个包含一个将 y 绑定到 x 的绑定的单元素映射。
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 是 m 中所有键严格小于 x 的绑定组成的映射；r 是 m 中所有键严格大于 x 的绑定组成的映射；data 如果 m 中不包含 x 的绑定，则为 None，如果 m 将 v 绑定到 x，则为 Some v。
val is_empty : 'a t -> bool测试映射是否为空。
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 测试映射 m1 和 m2 是否相等，即是否包含相同的键并将它们与相同的数据关联。 cmp 是用于比较与键关联的数据的相等性谓词。
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int映射之间的全序。第一个参数是用于比较两个映射中与相同键关联的数据的全序。
val for_all : (key -> 'a -> bool) -> 'a t -> boolfor_all f m 检查映射的所有绑定是否都满足谓词 f。
val exists : (key -> 'a -> bool) -> 'a t -> boolexists f m 检查映射中是否至少有一个绑定满足谓词 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 的绑定添加到空映射中，按列表顺序（如果一个键在 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.tto_seq_from k m 以升序的键顺序遍历 m 的绑定的子集，从键 k 或更高的键开始。
val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t按顺序将给定的绑定添加到映射中。
val of_seq : (key * 'a) Seq.t -> 'a t从给定的绑定构建一个映射。