CamomileLibrary.Type.UMap

# Module CamomileLibrary.Type.UMap

    module UMap: sig .. end

    type 'a t

Maps over Unicode characters.

    val empty : 'a t

    val is_empty : 'a t -> bool

    val add : ?eq:('a -> 'a -> bool) ->
           CamomileLibrary.Type.UChar.t ->
           'a -> 'a t -> 'a t

`add ?eq u v m` returns the new map which is same to `m` except it maps `u` to some value `v'` which satisfies `eq v v'`. If `eq` is not supplied, structural equality is used.

    val add_range : ?eq:('a -> 'a -> bool) ->
           CamomileLibrary.Type.UChar.t ->
           CamomileLibrary.Type.UChar.t ->
           'a -> 'a t -> 'a t

`add ?eq u1 u2 v m` returns the new map which is same to `m` except it maps characters in the range `u1`-`u2` to some value `v'` which satisfies `eq v v'`. If `eq` is not supplied, structural equality is used.

    val find : CamomileLibrary.Type.UChar.t -> 'a t -> 'a

    val remove : CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

    val remove_range : CamomileLibrary.Type.UChar.t ->
           CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

`remove_range u1 u2 m` removes `u1`-`u2` from the domain of `m`

    val from : CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

`from u m` restricts the domain of `m` to the characters whose code points are equal or greater than `u`.

    val after : CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

`after u m` restricts the domain of `m` to the characters whose code points are greater than `u`.

    val until : CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

`until u m` restricts the domain of `m` to the characters whose code points are equal or smaller than `u`.

    val before : CamomileLibrary.Type.UChar.t ->
           'a t -> 'a t

`before u m` restricts the domain of `m` to the characters whose code points are smaller than `u`.

    val mem : CamomileLibrary.Type.UChar.t -> 'a t -> bool

    val iter : (CamomileLibrary.Type.UChar.t -> 'a -> unit) ->
           'a t -> unit

    val iter_range : (CamomileLibrary.Type.UChar.t -> CamomileLibrary.Type.UChar.t -> 'a -> unit) ->
           'a t -> unit

`iter proc m` : For each contingent region `u1`-`u2` that is mapped to a constant `v`, `proc u1 u2 v` is called. The order of call is determined by increasing order on `u1`.
`map ?eq f m` and `mapi ?eq f m` : Similar to `map` and `mapi` in stdlib Map, but if the map `m'` is returned, it is only guaranteed that `eq (find u m') (f (find u m ))` is true for `map` and `eq (find u m') (f u (find u m ))` is true for `mapi`. If `eq` is not specified, structural equality is used.

    val map : ?eq:('a -> 'a -> bool) ->
           ('b -> 'a) ->
           'b t -> 'a t

    val mapi : ?eq:('a -> 'a -> bool) ->
           (CamomileLibrary.Type.UChar.t -> 'b -> 'a) ->
           'b t -> 'a t

    val fold : (CamomileLibrary.Type.UChar.t -> 'a -> 'b -> 'b) ->
           'a t -> 'b -> 'b

    val fold_range : (CamomileLibrary.Type.UChar.t ->
            CamomileLibrary.Type.UChar.t -> 'a -> 'b -> 'b) ->
           'a t -> 'b -> 'b

`fold_range f m x` is equivalent to `f u_(2n) u_(2n+1) v_n (... (f u_1 u_2 v_1 x))` where all characters in the range `u_(2k)`-`u_(2k+1)` are mapped to `v_k` and `u_1` < `u_3` < ... in code point order. For each range `u_(2k)`-`u_(2k+1)` is separated by a character which is not mapped to `v_k`.

    val set_to_map : CamomileLibrary.Type.USet.t -> 'a -> 'a t

Constant map.

    val domain : 'a t -> CamomileLibrary.Type.USet.t

Domain.

    val map_to_set : ('a -> bool) -> 'a t -> CamomileLibrary.Type.USet.t

`map_to_set p m` returns the set of characters which are mapped to values satisfying the predicate `p` by `m`.

    val umap_of_imap : 'a IMap.t -> 'a t

    val imap_of_umap : 'a t -> 'a IMap.t