module BatIMap:sig
..end
type 'a
t
typekey =
int
val empty : eq:('a -> 'a -> bool) -> 'a t
val singleton : eq:('a -> 'a -> bool) -> int -> 'a -> 'a t
val is_empty : 'a t -> bool
val add : int -> 'a -> 'a t -> 'a t
add x y t
adds a binding from x
to y
in t
, returning a new map.val add_range : int -> int -> 'a -> 'a t -> 'a t
add lo hi y t
adds bindings to y
for all values in the range
lo,hi
, returning a new mapval find : int -> 'a t -> 'a
find x t
returns the y
that is bound to x
in t
.Not_found
if x
is unboundval remove : int -> 'a t -> 'a t
val remove_range : int -> int -> 'a t -> 'a t
val from : int -> 'a t -> 'a t
x,max_int
val after : int -> 'a t -> 'a t
x+1,max_int
val until : int -> 'a t -> 'a t
min_int, x
val before : int -> 'a t -> 'a t
min_int, x-1
val mem : int -> 'a t -> bool
val iter : (int -> 'a -> unit) -> 'a t -> unit
iter f t
calls f
on every bindingval iter_range : (int -> int -> 'a -> unit) -> 'a t -> unit
iter_range f t
calls f
on every contiguous range. For maps, contiguous ranges must map to the same y
val map : ?eq:('b -> 'b -> bool) -> ('a -> 'b) -> 'a t -> 'b t
y
by the given function.
This will not create new ranges; the mapping function is only
applied to each contiguous range once. It is not applied to the
ranges in order. ~eq
defaults to (=).val mapi : ?eq:('b -> 'b -> bool) -> (int -> 'a -> 'b) -> 'a t -> 'b t
~eq
defaults to (=).val map_range : ?eq:('b -> 'b -> bool) ->
(int -> int -> 'a -> 'b) -> 'a t -> 'b t
y
using the given function.
This will not create new ranges, but will have access to the
lo,hi
of the current range. ~eq
defaults to (=).val fold : (int -> 'b -> 'a -> 'a) -> 'b t -> 'a -> 'a
fold f t x0
folds all the bindings of t
into x0
using f
to
merge.val fold_range : (int -> int -> 'b -> 'a -> 'a) -> 'b t -> 'a -> 'a
fold_range f t x0
folds all the contiguous ranges of t
into
x0
using f
to merge. The order of foldings is unspecified.val set_to_map : ?eq:('a -> 'a -> bool) -> BatISet.t -> 'a -> 'a t
set_to_map s x
returns a map where every element of s
is bound
to x
.val domain : 'a t -> BatISet.t
domain t
returns the set of ints that are bound in t
val map_to_set : ('a -> bool) -> 'a t -> BatISet.t
map_to_set p t
returns the set of keys of t
where p
evaluates as trueval enum : 'a t -> (int * int * 'a) BatEnum.t
enum t
returns an enumeration of the bindings in t
val fold2_range : (int -> int -> 'a option -> 'b option -> 'c -> 'c) ->
'a t -> 'b t -> 'c -> 'c
fold2_range f t u x0
folds across each range that's defined in
either t
or u
or both, giving that range and the possible values
to f
to merge with x0
.
Example: let union_first = fold2_range (fun _lo _hi a b = match a,b with Some x,_ -> x | _,Some y -> y)
val union : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val merge : ?eq:('c -> 'c -> bool) ->
(int -> int -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val forall2_range : (int -> int -> 'a option -> 'b option -> bool) ->
'a t -> 'b t -> bool
val get_dec_eq : 'a t -> 'a -> 'a -> bool
module Infix:sig
..end
BatIMap