# Module Bounded_int_table

    module Bounded_int_table: sig .. end

A `Bounded_int_table` is a table whose keys can be mapped to integers in a fixed range, 0 ... num_keys-1, where `num_keys` is specified at table-creation time. The purpose of `Bounded_int_table` is to be faster than `Hashtbl` in situations where one is willing to pay a space cost for the speed.

`Bounded_int_table` presents a subset of the `Hashtbl` interface. The key type can be any type, but table creation requires a `key_to_int` function, which will be used to extract the integer of all keys. If multiple keys map to the same integer, then only one of them can be in the table at a time. Any operation that supplies a key whose corresponding integer is outside the allowed range for the table will cause an exception.

A `Bounded_int_table` is implemented using two fixed size arrays of size `num_keys`, which are supplied at table-creation time. The space used does not depend on the `length` of the table but rather only on `num_keys`. Operations that deal with a single element (find, mem, add, remove, set) take constant time, and perform one or two array operations. Operations that deal with all of the keys defined in the table (data, fold, iter, iter_vals, keys, to_alist) take time proportional to the `length` of the table, not `num_keys`.

    type ('key, 'data) t

    type ('a, 'b) table = ('a, 'b) t

    include Invariant.S2

    include Equal.S2

Equality only requires the keys and values to be the same, not the bin or sexp formatting or the integers the keys correspond to (see `key_to_int`).

    val create : ?sexp_of_key:('key -> Std_internal.Sexp.t) ->
           num_keys:int ->
           key_to_int:('key -> int) -> unit -> ('key, 'data) t

`create ~num_keys ~key_to_int` returns a table where the keys can map to 0 .. num_keys-1, according to `key_to_int`. It is an error if `num_keys < 0`.

`sexp_of_key`, if supplied, will be used to display keys in error messages.

    val keys : ('key, 'a) t -> 'key list

Standard hashtbl functions.

    val data : ('a, 'data) t -> 'data list

    val find : ('key, 'data) t -> 'key -> 'data option

    val find_exn : ('key, 'data) t -> 'key -> 'data

    val find_or_add : ('key, 'data) t -> 'key -> default:(unit -> 'data) -> 'data

    val fold : ('key, 'data) t ->
           init:'accum -> f:(key:'key -> data:'data -> 'accum -> 'accum) -> 'accum

    val iter : ('key, 'data) t ->
           f:(key:'key -> data:'data -> unit) -> unit

    val iter_vals : ('a, 'data) t -> f:('data -> unit) -> unit

    val filter_mapi : ('key, 'data1) t ->
           f:(key:'key -> data:'data1 -> 'data2 option) ->
           ('key, 'data2) t

    val filter_map : ('key, 'data1) t ->
           f:('data1 -> 'data2 option) -> ('key, 'data2) t

    val mapi : ('key, 'data1) t ->
           f:(key:'key -> data:'data1 -> 'data2) -> ('key, 'data2) t

    val map : ('key, 'data1) t ->
           f:('data1 -> 'data2) -> ('key, 'data2) t

    val for_alli : ('key, 'data) t ->
           f:(key:'key -> data:'data -> bool) -> bool

    val existsi : ('key, 'data) t ->
           f:(key:'key -> data:'data -> bool) -> bool

    val for_all : ('a, 'data) t -> f:('data -> bool) -> bool

    val exists : ('a, 'data) t -> f:('data -> bool) -> bool

    val length : ('a, 'b) t -> int

    val mem : ('key, 'a) t -> 'key -> bool

    val remove : ('key, 'a) t -> 'key -> unit

    val set : ('a, 'b) t -> key:'a -> data:'b -> unit

    val add : ('a, 'b) t ->
           key:'a -> data:'b -> [ `Duplicate of 'b | `Ok ]

    val add_exn : ('a, 'b) t -> key:'a -> data:'b -> unit

    val to_alist : ('key, 'data) t -> ('key * 'data) list

    val clear : ('a, 'b) t -> unit

    module With_key: functor (Key : sig
    type t

    val to_int : t -> int
    val t_of_sexp : Sexplib.Sexp.t -> t
    val sexp_of_t : t -> Sexplib.Sexp.t
    val bin_t : t Bin_prot.Type_class.t
    val bin_read_t : t Bin_prot.Read.reader
    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
    val bin_reader_t : t Bin_prot.Type_class.reader
    val bin_size_t : t Bin_prot.Size.sizer
    val bin_write_t : t Bin_prot.Write.writer
    val bin_writer_t : t Bin_prot.Type_class.writerend) -> sig .. end

    val debug : bool Pervasives.ref

set `debug := true` to turn on debugging, including potentially slow invariant checking.

    val sexp_of_t : ('key -> Sexplib.Sexp.t) ->
           ('data -> Sexplib.Sexp.t) ->
           ('key, 'data) t -> Sexplib.Sexp.t

Equality only requires the keys and values to be the same, not the bin or sexp formatting or the integers the keys correspond to (see `key_to_int`).
`create ~num_keys ~key_to_int` returns a table where the keys can map to 0 .. num_keys-1, according to `key_to_int`. It is an error if `num_keys < 0`.

`sexp_of_key`, if supplied, will be used to display keys in error messages.
Standard hashtbl functions.
Serialization of a bounded int table using `bin_io` or `sexp` preserves `num_keys`, but only takes space proportional to the `length` of the table.
`of_alist` returns a table whose maximum allowed key is the maximum key in the input list.
set `debug := true` to turn on debugging, including potentially slow invariant checking.