Irmin, a distributed database that follows the same design principles as Git
type t

The type of mutable sets of fixed-length strings.

type elt := string
val create : elt_length:int -> ?initial_slots:int -> ?hash:( elt -> int ) -> ?hash_substring:( Bigstringaf.t -> off:int -> len:int -> int ) -> ?null:string -> unit -> t

create builds an empty set of fixed-length strings. The parameters are as follows:

  • elt_length: the length of each element string in bytes;
  • initial_slots: the minimum number of slots contained in the initial internal buffer (NOTE: the actual number of slots will be the least power of two greater than or equal to initial_buffer. This is not the same as the number of elements that can fit inside the buffer, which also depends on the maximum load factor);
  • hash / hash_substring: functions to use for placing elements inside the internal buffer (given that the element is contained in a string or a bigstring respectively). The stored elements must have uniformly distributed hash results for good performance, and the two hash functions must be equivalent. Defaults to Hashtbl.hash (and an equivalent function on substrings).
  • null: a string of size elt_length that is guaranteed to never be added to the hashset. Passing this string to add or mem after creating the hashset will result in an exception being raised.
val add : t -> elt -> [ `Ok | `Duplicate ]

add t elt adds elt to the set t and returns `Ok if elt is not already a member of t, otherwise returns `Duplicate and leaves the hashset unchanged.

val add_exn : t -> elt -> unit

add_exn t elt adds elt to the set t.

  • raises Invalid_argument

    if elt is already a member of t.

val mem : t -> elt -> bool

mem t elt is true iff elt has been added to the hashset.

val invariant : ( elt -> unit ) -> t -> unit

invariant f t checks the internal invariants of t and calls f on every element contained within. Exposed for testing.

val reachable_words : t -> int

reachable_words t is the total number of words of data kept alive by t (on both the C and OCaml heaps).