Module BatIMap Source DIET Maps from integers, packed using ranges
Source val empty : eq :('a -> 'a -> -> 'a t The empty map. Needs one parameter: a comparison function for the values, to enable merging of ranges with identical values.
Source val singleton : eq :('a -> 'a -> -> int -> 'a -> 'a t Test whether a map is empty (i.e. has no bindings)
Source 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.
Source val add_range : int -> int -> 'a -> 'a t -> 'a t add_range lo hi y t adds bindings to y for all values in the range lo,hi, returning a new map
find x t returns the y that is bound to x in t.
Source val modify : int -> ('a -> 'a ) -> 'a t -> 'a t modify x f t replaces the y that is bound to x in t by f y.
Source val modify_def : 'a -> int -> ('a -> 'a ) -> 'a t -> 'a t modify_def dft x f t does the same as modify x f t but binds x to f dft if x was not bound.
Source val modify_opt : int -> ('a option-> 'a option -> 'a t -> 'a t modify_opt x f t allows to modify the binding for x in t or absence thereof.
Remove any bindings from the given value.
Source val remove_range : int -> int -> 'a t -> 'a t Remove any bindings within the given range
Return the sub-map of bindings in the range x,max_int
Return the sub-map of bindings in the range x+1,max_int
Return the sub-map of bindings in the range min_int, x
Return the sub-map of bindings in the range min_int, x-1
Source val mem : int -> 'a t -> Test whether there is a binding from the given int
Source val iter : (int -> 'a -> -> 'a t -> iter f t calls f on every binding
Source val iter_range : (int -> int -> 'a -> -> 'a t -> iter_range f t calls f on every contiguous range. For maps, contiguous ranges must map to the same y
Source val map : ?eq :('b -> 'b -> -> ('a -> 'b ) -> 'a t -> 'b t Create a new map by modifying each 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 (=).
Source val mapi : ?eq :('b -> 'b -> -> (int -> 'a -> 'b ) -> 'a t -> 'b t Create a new map by computing new values based on key and value of the existing bindings. This can create new ranges, as adjacent bindings can be assigned different values. ~eq defaults to (=).
Source val map_range :
?eq :('b -> 'b -> -> (int -> int -> 'a -> 'b ) -> 'a t -> 'b t Create a new map by modifying each 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 (=).
Source 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.
Source 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.
set_to_map s x returns a map where every element of s is bound to x.
Source val domain : 'a t -> BatISet.t domain t returns the set of ints that are bound in t
map_to_set p t returns the set of keys of t where p evaluates as true
enum t returns an enumeration of the bindings in t
of_enum e returns the set of given ranges
Source 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)
Source val union : ('a -> 'a -> 'a ) -> 'a t -> 'a t -> 'a t Merge two maps, giving a value
Source val merge :
?eq :('c -> 'c -> -> (int -> int -> 'a option-> 'b option-> 'c option -> 'a t -> 'b t -> 'c t Source val forall2_range :
(int -> int -> 'a option-> 'b option-> -> 'a t -> 'b t -> Source val get_dec_eq : 'a t -> 'a -> 'a -> Get the equality function used in an IMap.t