1Depend.StringMap(3)              OCaml library             Depend.StringMap(3)
2
3
4

NAME

6       Depend.StringMap - no description
7

Module

9       Module   Depend.StringMap
10

Documentation

12       Module StringMap
13        : sig end
14
15
16
17
18
19
20
21       type key
22
23
24       The type of the map keys.
25
26
27       type +'a t
28
29
30       The type of maps from type key to type 'a .
31
32
33
34       val empty : 'a t
35
36       The empty map.
37
38
39
40       val is_empty : 'a t -> bool
41
42       Test whether a map is empty or not.
43
44
45
46       val mem : key -> 'a t -> bool
47
48
49       mem  x  m returns true if m contains a binding for x , and false other‐
50       wise.
51
52
53
54       val add : key -> 'a -> 'a t -> 'a t
55
56
57       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
63
64       Before4.03 Physical equality was not ensured.
65
66
67
68
69       val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
70
71
72       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
80
81       Since 4.06.0
82
83
84
85       val singleton : key -> 'a -> 'a t
86
87
88       singleton x y returns the one-element map that contains a binding y for
89       x .
90
91
92       Since 3.12.0
93
94
95
96       val remove : key -> 'a t -> 'a t
97
98
99       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
101       returned unchanged (the result of the function is then physically equal
102       to m ).
103
104
105       Before4.03 Physical equality was not ensured.
106
107
108
109
110       val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t ->  'b
111       t -> 'c t
112
113
114       merge  f  m1 m2 computes a map whose keys is a subset of keys of m1 and
115       of m2 . The presence of each such binding, and the corresponding value,
116       is  determined  with  the function f .  In terms of the find_opt opera‐
117       tion, we have find_opt x (merge f m1 m2) = f (find_opt x m1)  (find_opt
118       x m2) for any key x , provided that f None None = None .
119
120
121       Since 3.12.0
122
123
124
125       val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
126
127
128       union  f m1 m2 computes a map whose keys is the union of keys of m1 and
129       of m2 .  When the same binding is defined in both arguments, the  func‐
130       tion  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
133       - f' None None = None
134
135
136       - f' (Some v) None = Some v
137
138
139       - f' None (Some v) = Some v
140
141
142       - f' (Some v1) (Some v2) = f v1 v2
143
144
145
146
147       Since 4.03.0
148
149
150
151       val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
152
153       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
156
157
158       val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
159
160
161       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
165
166
167       val iter : (key -> 'a -> unit) -> 'a t -> unit
168
169
170       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
175
176
177       val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
178
179
180       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
184
185
186       val for_all : (key -> 'a -> bool) -> 'a t -> bool
187
188
189       for_all p m checks if all the bindings of the map satisfy the predicate
190       p .
191
192
193       Since 3.12.0
194
195
196
197       val exists : (key -> 'a -> bool) -> 'a t -> bool
198
199
200       exists  p  m  checks  if  at least one binding of the map satisfies the
201       predicate p .
202
203
204       Since 3.12.0
205
206
207
208       val filter : (key -> 'a -> bool) -> 'a t -> 'a t
209
210
211       filter p m returns the map with all the  bindings  in  m  that  satisfy
212       predicate  p  .  If  p  satisfies  every  binding  in m , m is returned
213       unchanged (the result of the function is then physically equal to m )
214
215
216       Before4.03 Physical equality was not ensured.
217
218
219
220       Since 3.12.0
221
222
223
224       val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
225
226
227       partition p m returns a pair of maps (m1, m2) , where m1  contains  all
228       the bindings of s that satisfy the predicate p , and m2 is the map with
229       all the bindings of s that do not satisfy p .
230
231
232       Since 3.12.0
233
234
235
236       val cardinal : 'a t -> int
237
238       Return the number of bindings of a map.
239
240
241       Since 3.12.0
242
243
244
245       val bindings : 'a t -> (key * 'a) list
246
247       Return the list of all bindings of the given map.  The returned list is
248       sorted  in  increasing order with respect to the ordering Ord.compare ,
249       where Ord is the argument given to Map.Make .
250
251
252       Since 3.12.0
253
254
255
256       val min_binding : 'a t -> key * 'a
257
258       Return the smallest binding of the  given  map  (with  respect  to  the
259       Ord.compare ordering), or raise Not_found if the map is empty.
260
261
262       Since 3.12.0
263
264
265
266       val min_binding_opt : 'a t -> (key * 'a) option
267
268       Return  the  smallest  binding  of  the  given map (with respect to the
269       Ord.compare ordering), or None if the map is empty.
270
271
272       Since 4.05
273
274
275
276       val max_binding : 'a t -> key * 'a
277
278       Same as Map.S.min_binding , but returns  the  largest  binding  of  the
279       given map.
280
281
282       Since 3.12.0
283
284
285
286       val max_binding_opt : 'a t -> (key * 'a) option
287
288       Same  as Map.S.min_binding_opt , but returns the largest binding of the
289       given map.
290
291
292       Since 4.05
293
294
295
296       val choose : 'a t -> key * 'a
297
298       Return one binding of the given map, or raise Not_found if the  map  is
299       empty.  Which binding is chosen is unspecified, but equal bindings will
300       be chosen for equal maps.
301
302
303       Since 3.12.0
304
305
306
307       val choose_opt : 'a t -> (key * 'a) option
308
309       Return one binding of the given map, or None if the map is empty. Which
310       binding is chosen is unspecified, but equal bindings will be chosen for
311       equal maps.
312
313
314       Since 4.05
315
316
317
318       val split : key -> 'a t -> 'a t * 'a option * 'a t
319
320
321       split x m returns a triple (l, data, r) , where l is the map  with  all
322       the bindings of m whose key is strictly less than x ; r is the map with
323       all the bindings of m whose key is strictly greater than x  ;  data  is
324       None if m contains no binding for x , or Some v if m binds v to x .
325
326
327       Since 3.12.0
328
329
330
331       val find : key -> 'a t -> 'a
332
333
334       find x m returns the current binding of x in m , or raises Not_found if
335       no such binding exists.
336
337
338
339       val find_opt : key -> 'a t -> 'a option
340
341
342       find_opt x m returns Some v if the current binding of x in m is v ,  or
343       None if no such binding exists.
344
345
346       Since 4.05
347
348
349
350       val find_first : (key -> bool) -> 'a t -> key * 'a
351
352
353       find_first  f  m  ,  where  f  is  a monotonically increasing function,
354       returns the binding of m with the lowest key k  such  that  f  k  ,  or
355       raises Not_found if no such key exists.
356
357       For  example,  find_first (fun k -> Ord.compare k x >= 0) m will return
358       the first binding k, v of m where Ord.compare k x >= 0 (intuitively:  k
359       >= x ), or raise Not_found if x is greater than any element of m .
360
361
362       Since 4.05
363
364
365
366       val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
367
368
369       find_first_opt  f  m  , where f is a monotonically increasing function,
370       returns an option containing the binding of m with  the  lowest  key  k
371       such that f k , or None if no such key exists.
372
373
374       Since 4.05
375
376
377
378       val find_last : (key -> bool) -> 'a t -> key * 'a
379
380
381       find_last f m , where f is a monotonically decreasing function, returns
382       the binding of m with the highest key k such  that  f  k  ,  or  raises
383       Not_found if no such key exists.
384
385
386       Since 4.05
387
388
389
390       val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
391
392
393       find_last_opt  f  m  ,  where f is a monotonically decreasing function,
394       returns an option containing the binding of m with the  highest  key  k
395       such that f k , or None if no such key exists.
396
397
398       Since 4.05
399
400
401
402       val map : ('a -> 'b) -> 'a t -> 'b t
403
404
405       map  f  m  returns  a  map with same domain as m , where the associated
406       value a of all bindings of m has been replaced by  the  result  of  the
407       application  of  f  to  a .  The bindings are passed to f in increasing
408       order with respect to the ordering over the type of the keys.
409
410
411
412       val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
413
414       Same as Map.S.map , but the function receives as arguments both the key
415       and the associated value for each binding of the map.
416
417
418
419
420       === Iterators ===
421
422
423       val to_seq : 'a t -> (key * 'a) Seq.t
424
425       Iterate on the whole map, in ascending order
426
427
428       Since 4.07
429
430
431
432       val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
433
434
435       to_seq_from  k m iterates on a subset of the bindings of m , in ascend‐
436       ing order, from key k or above.
437
438
439       Since 4.07
440
441
442
443       val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
444
445       Add the given bindings to the map, in order.
446
447
448       Since 4.07
449
450
451
452       val of_seq : (key * 'a) Seq.t -> 'a t
453
454       Build a map from the given bindings
455
456
457       Since 4.07
458
459
460
461
462
463OCamldoc                          2019-02-02               Depend.StringMap(3)