# Module BatIMap

    module BatIMap: sig .. end

DIET Maps from integers, packed using ranges

    type 'a t = (int * int * 'a) BatAvlTree.tree

    type key = int

    val empty : 'a t

    val is_empty : 'a t -> bool

    val add : ?eq:('a -> 'a -> bool) -> int -> 'a -> 'a t -> 'a t

    val add_range : ?eq:('a -> 'a -> bool) -> int -> int -> 'a -> 'a t -> 'a t

    val find : int -> 'a t -> 'a

    val remove : int -> 'a t -> 'a t

    val remove_range : int -> int -> 'a t -> 'a t

    val from : int -> 'a t -> 'a t

    val after : int -> 'a t -> 'a t

    val until : int -> 'a t -> 'a t

    val before : int -> 'a t -> 'a t

    val mem : int -> 'a t -> bool

    val iter : (int -> 'a -> unit) -> 'a t -> unit

    val iter_range : (int -> int -> 'a -> unit) -> 'a t -> unit

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

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

    val fold : (int -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b

    val fold_range : (int -> int -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b

    val set_to_map : BatISet.t -> 'a -> 'a t

    val domain : 'a t -> BatISet.t

    val map_to_set : ('a -> bool) -> 'a t -> BatISet.t

    val enum : 'a t -> (int * int * 'a) BatEnum.t

    val fold2_range : (int -> int -> 'a option -> 'b option -> 'c -> 'c) ->
           'a t -> 'b t -> 'c -> 'c

    val union : ('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

    module Infix: sig .. end

Infix operators over a `BatIMap`