模块类型 MoreLabels.Map.S

module type S = sig .. end

函子 MoreLabels.Map.Make 的输出签名。

映射

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 物理相等的 value，则返回未更改的 m（函数的结果在物理上等于 m）。否则，m 中 key 的先前绑定将消失。

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

add_to_list ~key ~data m 是 m，其中 key 映射到 l，这样 l 等于 data :: Map.find key m（如果 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 物理相等的 value，则返回未更改的 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 键的子集。每个此类绑定的存在和相应的 value 由函数 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

返回映射的绑定数量。

绑定

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

返回给定映射的所有绑定的列表。返回的列表按键的升序排列，该排序与 Ord.compare 排序一致，其中 Ord 是传递给 MoreLabels.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

与 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。选择哪个绑定是未指定的，但对于相等的映射，将选择相等的绑定。

搜索

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

find x m 返回 x 在 m 中的当前 value，或者如果不存在 x 的绑定，则引发 Not_found。

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

find_opt x m 返回 Some v（如果 x 在 m 中的当前 value 为 v），或者如果不存在 x 的绑定，则返回 None。

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

find_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 : f:(key -> bool) ->
       'a t -> (key * 'a) option

find_first_opt ~f m（其中 f 是一个单调递增函数）返回一个包含 m 的绑定的选项，该绑定具有最低的键 k，使得 f k，或者如果不存在这样的键，则返回 None。

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

find_last ~f m（其中 f 是一个单调递减函数）返回 m 的绑定，该绑定具有最高的键 k，使得 f k，或者如果不存在这样的键，则引发 Not_found。

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

find_last_opt ~f m（其中 f 是一个单调递减函数）返回一个包含 m 的绑定的选项，该绑定具有最高的键 k，使得 f k，或者如果不存在这样的键，则返回 None。

遍历

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

iter ~f m 将 f 应用于映射 m 中的所有绑定。 f 以键作为第一个参数接收，以关联的 value 作为第二个参数接收。绑定按键类型的排序顺序（升序）传递给 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 是关联的数据。

转换

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

map ~f m 返回一个与 m 具有相同域的映射，其中 m 的所有绑定的关联 value a 已被 f 应用于 a 的结果替换。绑定按键类型的排序顺序（升序）传递给 f。

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

与 MoreLabels.Map.S.map 相同，但函数接收键和每个映射绑定的关联 value 作为参数。

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

filter ~f m 返回包含所有满足谓词 p 的 m 绑定映射。如果 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') 位于输出映射中。

例如，以下函数在 value 为列表的映射上

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

删除所有 value 为空列表的 m 绑定，并弹出每个非空 value 的第一个元素。

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

partition ~f m 返回一对映射 (m1, m2)，其中 m1 包含满足谓词 f 的所有 m 绑定，m2 是包含所有不满足 f 的 m 绑定的映射。

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

split x m 返回一个三元组 (l, data, r)，其中 l 是包含所有键严格小于 x 的 m 绑定的映射；r 是包含所有键严格大于 x 的 m 绑定的映射；data 如果 m 不包含 x 的绑定，则为 None，或者如果 m 将 v 绑定到 x，则为 Some v。

谓词和比较

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。

转换

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 按键的升序遍历 m 的绑定子集，从键 k 或更高处开始。

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

按顺序将给定的绑定添加到映射中。

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

从给定的绑定构建映射