1Misc.Stdlib.String.Map(3) OCaml library Misc.Stdlib.String.Map(3)
2
6 Misc.Stdlib.String.Map - no description
7
9 Module Misc.Stdlib.String.Map
10
12 Module Map
13 : sig end
14 type key
22 The type of the map keys.
25 type +'a t
28 The type of maps from type key to type 'a .
31 val empty : 'a t
35 The empty map.
37 val is_empty : 'a t -> bool
41 Test whether a map is empty or not.
43 val mem : key -> 'a t -> bool
47 mem x m returns true if m contains a binding for x , and false other‐
50 wise.
51 val add : key -> 'a -> 'a t -> 'a t
55 add x y m returns a map containing the same bindings as m , plus a
58 binding of x to y . If x was already bound in m to a value that is
59 physically equal to y , m is returned unchanged (the result of the
60 function is then physically equal to m ). Otherwise, the previous bind‐
61 ing of x in m disappears.
62 Before4.03 Physical equality was not ensured.
65 val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
70 update x f m returns a map containing the same bindings as m , except
73 for the binding of x . Depending on the value of y where y is f
74 (find_opt x m) , the binding of x is added, removed or updated. If y is
75 None , the binding is removed if it exists; otherwise, if y is Some z
76 then x is associated to z in the resulting map. If x was already bound
77 in m to a value that is physically equal to z , m is returned unchanged
78 (the result of the function is then physically equal to m ).
79 Since 4.06.0
82 val singleton : key -> 'a -> 'a t
86 singleton x y returns the one-element map that contains a binding y for
89 x .
90 Since 3.12.0
93 val remove : key -> 'a t -> 'a t
97 remove x m returns a map containing the same bindings as m , except for
100 x which is unbound in the returned map. If x was not in m , m is re‐
101 turned unchanged (the result of the function is then physically equal
102 to m ).
103 Before4.03 Physical equality was not ensured.
106 val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b
111 t -> 'c t
112 merge f m1 m2 computes a map whose keys are a subset of the keys of m1
115 and of m2 . The presence of each such binding, and the corresponding
116 value, is determined with the function f . In terms of the find_opt
117 operation, we have find_opt x (merge f m1 m2) = f x (find_opt x m1)
118 (find_opt x m2) for any key x , provided that f x None None = None .
119 Since 3.12.0
122 val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
126 union f m1 m2 computes a map whose keys are a subset of the keys of m1
129 and of m2 . When the same binding is defined in both arguments, the
130 function f is used to combine them. This is a special case of merge :
131 union f m1 m2 is equivalent to merge f' m1 m2 , where
132 - f' _key None None = None
134 - f' _key (Some v) None = Some v
137 - f' _key None (Some v) = Some v
140 - f' key (Some v1) (Some v2) = f key v1 v2
143 Since 4.03.0
148 val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
152 Total ordering between maps. The first argument is a total ordering
154 used to compare data associated with equal keys in the two maps.
155 val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
159 equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is,
162 contain equal keys and associate them with equal data. cmp is the
163 equality predicate used to compare the data associated with the keys.
164 val iter : (key -> 'a -> unit) -> 'a t -> unit
168 iter f m applies f to all bindings in map m . f receives the key as
171 first argument, and the associated value as second argument. The bind‐
172 ings are passed to f in increasing order with respect to the ordering
173 over the type of the keys.
174 val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
178 fold f m a computes (f kN dN ... (f k1 d1 a)...) , where k1 ... kN are
181 the keys of all bindings in m (in increasing order), and d1 ... dN are
182 the associated data.
183 val for_all : (key -> 'a -> bool) -> 'a t -> bool
187 for_all p m checks if all the bindings of the map satisfy the predicate
190 p .
191 Since 3.12.0
194 val exists : (key -> 'a -> bool) -> 'a t -> bool
198 exists p m checks if at least one binding of the map satisfies the
201 predicate p .
202 Since 3.12.0
205 val filter : (key -> 'a -> bool) -> 'a t -> 'a t
209 filter p m returns the map with all the bindings in m that satisfy
212 predicate p . If every binding in m satisfies p , m is returned un‐
213 changed (the result of the function is then physically equal to m )
214 Before4.03 Physical equality was not ensured.
217 Since 3.12.0
221 val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
225 filter_map f m applies the function f to every binding of m , and
228 builds a map from the results. For each binding (k, v) in the input
229 map:
230 -if f k v is None then k is not in the result,
232 -if f k v is Some v' then the binding (k, v') is in the output map.
234 For example, the following function on maps whose values are lists
236 filter_map
237 (fun _k li -> match li with [] -> None | _::tl -> Some tl)
238 m
239 drops all bindings of m whose value is an empty list, and pops the
241 first element of each value that is non-empty.
242 Since 4.11.0
245 val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
249 partition p m returns a pair of maps (m1, m2) , where m1 contains all
252 the bindings of m that satisfy the predicate p , and m2 is the map with
253 all the bindings of m that do not satisfy p .
254 Since 3.12.0
257 val cardinal : 'a t -> int
261 Return the number of bindings of a map.
263 Since 3.12.0
266 val bindings : 'a t -> (key * 'a) list
270 Return the list of all bindings of the given map. The returned list is
272 sorted in increasing order of keys with respect to the ordering
273 Ord.compare , where Ord is the argument given to Map.Make .
274 Since 3.12.0
277 val min_binding : 'a t -> key * 'a
281 Return the binding with the smallest key in a given map (with respect
283 to the Ord.compare ordering), or raise Not_found if the map is empty.
284 Since 3.12.0
287 val min_binding_opt : 'a t -> (key * 'a) option
291 Return the binding with the smallest key in the given map (with respect
293 to the Ord.compare ordering), or None if the map is empty.
294 Since 4.05
297 val max_binding : 'a t -> key * 'a
301 Same as Map.S.min_binding , but returns the binding with the largest
303 key in the given map.
304 Since 3.12.0
307 val max_binding_opt : 'a t -> (key * 'a) option
311 Same as Map.S.min_binding_opt , but returns the binding with the
313 largest key in the given map.
314 Since 4.05
317 val choose : 'a t -> key * 'a
321 Return one binding of the given map, or raise Not_found if the map is
323 empty. Which binding is chosen is unspecified, but equal bindings will
324 be chosen for equal maps.
325 Since 3.12.0
328 val choose_opt : 'a t -> (key * 'a) option
332 Return one binding of the given map, or None if the map is empty. Which
334 binding is chosen is unspecified, but equal bindings will be chosen for
335 equal maps.
336 Since 4.05
339 val split : key -> 'a t -> 'a t * 'a option * 'a t
343 split x m returns a triple (l, data, r) , where l is the map with all
346 the bindings of m whose key is strictly less than x ; r is the map with
347 all the bindings of m whose key is strictly greater than x ; data is
348 None if m contains no binding for x , or Some v if m binds v to x .
349 Since 3.12.0
352 val find : key -> 'a t -> 'a
356 find x m returns the current value of x in m , or raises Not_found if
359 no binding for x exists.
360 val find_opt : key -> 'a t -> 'a option
364 find_opt x m returns Some v if the current value of x in m is v , or
367 None if no binding for x exists.
368 Since 4.05
371 val find_first : (key -> bool) -> 'a t -> key * 'a
375 find_first f m , where f is a monotonically increasing function, re‐
378 turns the binding of m with the lowest key k such that f k , or raises
379 Not_found if no such key exists.
380 For example, find_first (fun k -> Ord.compare k x >= 0) m will return
382 the first binding k, v of m where Ord.compare k x >= 0 (intuitively: k
383 >= x ), or raise Not_found if x is greater than any element of m .
384 Since 4.05
387 val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
391 find_first_opt f m , where f is a monotonically increasing function,
394 returns an option containing the binding of m with the lowest key k
395 such that f k , or None if no such key exists.
396 Since 4.05
399 val find_last : (key -> bool) -> 'a t -> key * 'a
403 find_last f m , where f is a monotonically decreasing function, returns
406 the binding of m with the highest key k such that f k , or raises
407 Not_found if no such key exists.
408 Since 4.05
411 val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
415 find_last_opt f m , where f is a monotonically decreasing function, re‐
418 turns an option containing the binding of m with the highest key k such
419 that f k , or None if no such key exists.
420 Since 4.05
423 val map : ('a -> 'b) -> 'a t -> 'b t
427 map f m returns a map with same domain as m , where the associated
430 value a of all bindings of m has been replaced by the result of the ap‐
431 plication of f to a . The bindings are passed to f in increasing order
432 with respect to the ordering over the type of the keys.
433 val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
437 Same as Map.S.map , but the function receives as arguments both the key
439 and the associated value for each binding of the map.
440 Iterators
445 val to_seq : 'a t -> (key * 'a) Seq.t
446 Iterate on the whole map, in ascending order of keys
448 Since 4.07
451 val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
455 to_seq_from k m iterates on a subset of the bindings of m , in ascend‐
458 ing order of keys, from key k or above.
459 Since 4.07
462 val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
466 Add the given bindings to the map, in order.
468 Since 4.07
471 val of_seq : (key * 'a) Seq.t -> 'a t
475 Build a map from the given bindings
477 Since 4.07
480OCamldoc 2021-01-26 Misc.Stdlib.String.Map(3)