#### astring

Library

Module

Module type

Parameter

Class

Class type

## String maps

`include Map.S with type key := string`

`val empty : 'a t`

The empty map.

`val is_empty : 'a t -> bool`

Test whether a map is empty or not.

`val mem : string -> 'a t -> bool`

`mem x m`

returns `true`

if `m`

contains a binding for `x`

, and `false`

otherwise.

`add x y m`

returns a map containing the same bindings as `m`

, plus a binding of `x`

to `y`

. If `x`

was already bound in `m`

to a value that is physically equal to `y`

, `m`

is returned unchanged (the result of the function is then physically equal to `m`

). Otherwise, the previous binding of `x`

in `m`

disappears.

`update x f m`

returns a map containing the same bindings as `m`

, except for the binding of `x`

. Depending on the value of `y`

where `y`

is `f (find_opt x m)`

, the binding of `x`

is added, removed or updated. If `y`

is `None`

, the binding is removed if it exists; otherwise, if `y`

is `Some z`

then `x`

is associated to `z`

in the resulting map. If `x`

was already bound in `m`

to a value that is physically equal to `z`

, `m`

is returned unchanged (the result of the function is then physically equal to `m`

).

`val singleton : string -> 'a -> 'a t`

`singleton x y`

returns the one-element map that contains a binding `y`

for `x`

.

`remove x m`

returns a map containing the same bindings as `m`

, except for `x`

which is unbound in the returned map. If `x`

was not in `m`

, `m`

is returned unchanged (the result of the function is then physically equal to `m`

).

`merge f m1 m2`

computes a map whose keys is a subset of keys of `m1`

and of `m2`

. The presence of each such binding, and the corresponding value, is determined with the function `f`

. In terms of the `find_opt`

operation, we have `find_opt x (merge f m1 m2) = f (find_opt x m1) (find_opt x m2)`

for any key `x`

, provided that `f None None = None`

.

`union f m1 m2`

computes a map whose keys is the union of keys of `m1`

and of `m2`

. When the same binding is defined in both arguments, the function `f`

is used to combine them. This is a special case of `merge`

: `union f m1 m2`

is equivalent to `merge f' m1 m2`

, where

`f' None None = None`

`f' (Some v) None = Some v`

`f' None (Some v) = Some v`

`f' (Some v1) (Some v2) = f v1 v2`

Total ordering between maps. The first argument is a total ordering used to compare data associated with equal keys in the two maps.

`equal cmp m1 m2`

tests whether the maps `m1`

and `m2`

are equal, that is, contain equal keys and associate them with equal data. `cmp`

is the equality predicate used to compare the data associated with the keys.

`val iter : ( string -> 'a -> unit ) -> 'a t -> unit`

`iter f m`

applies `f`

to all bindings in map `m`

. `f`

receives the key as first argument, and the associated value as second argument. The bindings are passed to `f`

in increasing order with respect to the ordering over the type of the keys.

`val fold : ( string -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b`

`fold f m a`

computes `(f kN dN ... (f k1 d1 a)...)`

, where `k1 ... kN`

are the keys of all bindings in `m`

(in increasing order), and `d1 ... dN`

are the associated data.

`val for_all : ( string -> 'a -> bool ) -> 'a t -> bool`

`for_all p m`

checks if all the bindings of the map satisfy the predicate `p`

.

`val exists : ( string -> 'a -> bool ) -> 'a t -> bool`

`exists p m`

checks if at least one binding of the map satisfies the predicate `p`

.

`filter p m`

returns the map with all the bindings in `m`

that satisfy predicate `p`

. If `p`

satisfies every binding in `m`

, `m`

is returned unchanged (the result of the function is then physically equal to `m`

)

`partition p m`

returns a pair of maps `(m1, m2)`

, where `m1`

contains all the bindings of `s`

that satisfy the predicate `p`

, and `m2`

is the map with all the bindings of `s`

that do not satisfy `p`

.

`val cardinal : 'a t -> int`

Return the number of bindings of a map.

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

Return the list of all bindings of the given map. The returned list is sorted in increasing order with respect to the ordering `Ord.compare`

, where `Ord`

is the argument given to `Map`

.Make.

`val min_binding_opt : 'a t -> (string * 'a) option`

Return the smallest binding of the given map (with respect to the `Ord.compare`

ordering), or `None`

if the map is empty.

`val max_binding_opt : 'a t -> (string * 'a) option`

Same as `Map`

.S.min_binding_opt, but returns the largest binding of the given map.

`val choose_opt : 'a t -> (string * 'a) option`

Return one binding of the given map, or `None`

if the map is empty. Which binding is chosen is unspecified, but equal bindings will be chosen for equal maps.

`split x m`

returns a triple `(l, data, r)`

, where `l`

is the map with all the bindings of `m`

whose key is strictly less than `x`

; `r`

is the map with all the bindings of `m`

whose key is strictly greater than `x`

; `data`

is `None`

if `m`

contains no binding for `x`

, or `Some v`

if `m`

binds `v`

to `x`

.

`val find_opt : string -> 'a t -> 'a option`

`find_opt x m`

returns `Some v`

if the current binding of `x`

in `m`

is `v`

, or `None`

if no such binding exists.

`val find_first : ( string -> bool ) -> 'a t -> string * 'a`

`find_first f m`

, where `f`

is a monotonically increasing function, returns the binding of `m`

with the lowest key `k`

such that `f k`

, or raises `Not_found`

if no such key exists.

For example, `find_first (fun k -> Ord.compare k x >= 0) m`

will return the first binding `k, v`

of `m`

where `Ord.compare k x >= 0`

(intuitively: `k >= x`

), or raise `Not_found`

if `x`

is greater than any element of `m`

.

`val find_first_opt : ( string -> bool ) -> 'a t -> (string * 'a) option`

`find_first_opt f m`

, where `f`

is a monotonically increasing function, returns an option containing the binding of `m`

with the lowest key `k`

such that `f k`

, or `None`

if no such key exists.

`val find_last : ( string -> bool ) -> 'a t -> string * 'a`

`find_last f m`

, where `f`

is a monotonically decreasing function, returns the binding of `m`

with the highest key `k`

such that `f k`

, or raises `Not_found`

if no such key exists.

`val find_last_opt : ( string -> bool ) -> 'a t -> (string * 'a) option`

`find_last_opt f m`

, where `f`

is a monotonically decreasing function, returns an option containing the binding of `m`

with the highest key `k`

such that `f k`

, or `None`

if no such key exists.

`map f m`

returns a map with same domain as `m`

, where the associated value `a`

of all bindings of `m`

has been replaced by the result of the application of `f`

to `a`

. The bindings are passed to `f`

in increasing order with respect to the ordering over the type of the keys.

`val min_binding : 'a t -> (string * 'a) option`

Exception safe `Map`

.S.min_binding.

`val get_min_binding : 'a t -> string * 'a`

`get_min_binding`

is like `min_binding`

but

`val max_binding : 'a t -> (string * 'a) option`

Exception safe `Map`

.S.max_binding.

`val get_max_binding : 'a t -> string * 'a`

`get_max_binding`

is like `max_binding`

but

`val choose : 'a t -> (string * 'a) option`

Exception safe `Map`

.S.choose.

`val find : string -> 'a t -> 'a option`

Exception safe `Map`

.S.find.

`val get : string -> 'a t -> 'a`

`get k m`

is like `Map`

.S.find but raises `Invalid_argument`

if `k`

is not bound in `m`

.

`val of_list : (string * 'a) list -> 'a t`

`of_list bs`

is ```
List.fold_left (fun m (k, v) -> add k v m) empty
bs
```

.

`val of_stdlib_map : 'a Map.Make(String).t -> 'a t`

`of_stdlib_map m`

is a map from the stdlib-compatible map `m`

.

`val to_stdlib_map : 'a t -> 'a Map.Make(String).t`

`to_stdlib_map m`

is the stdlib-compatible map equivalent to `m`

.

```
val pp :
?sep:( Format.formatter -> unit -> unit ) ->
( Format.formatter -> (string * 'a) -> unit ) ->
Format.formatter ->
'a t ->
unit
```

`pp ~sep pp_binding ppf m`

formats the bindings of `m`

on `ppf`

. Each binding is formatted with `pp_binding`

and bindings are separated by `sep`

(defaults to `Format.pp_print_cut`

). If the map is empty leaves `ppf`

untouched.

```
val dump :
( Format.formatter -> 'a -> unit ) ->
Format.formatter ->
'a t ->
unit
```

`dump pp_v ppf m`

prints an unspecified representation of `m`

on `ppf`

using `pp_v`

to print the map codomain elements.

`val dump_string_map : Format.formatter -> string t -> unit`

`dump_string_map ppf m`

prints an unspecified representation of the string map `m`

on `ppf`

.