## `hashtbl`: hash tables and hash functions

  Hash tables are hashed association tables, with in-place modification.

    type ('a, 'b) t

  The type of hash tables from type `'a` to type `'b`.

    value new : int -> ('a,'b) t

  `new n` creates a new, empty hash table, with initial size `n`. The table grows as needed, so `n` is just an initial guess. Better results are said to be achieved when `n` is a prime number. Raise `Invalid_argument "hashtbl__new"` if `n` is less than 1.

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

  Empty a hash table.

    value add : ('a, 'b) t -> 'a -> 'b -> unit

  `add tbl x y` adds a binding of `x` to `y` in table `tbl`. Previous bindings for `x` are not removed, but simply hidden. That is, after performing `remove tbl x`, the previous binding for `x`, if any, is restored. (This is the semantics of association lists.)

    value find : ('a, 'b) t -> 'a -> 'b

  `find tbl x` returns the current binding of `x` in `tbl`, or raises `Not_found` if no such binding exists.

    value find_all : ('a, 'b) t -> 'a -> 'b list

  `find_all tbl x` returns the list of all data associated with `x` in `tbl`. The current binding is returned first, then the previous bindings, in reverse order of introduction in the table.

    value remove : ('a, 'b) t -> 'a -> unit

  `remove tbl x` removes the current binding of `x` in `tbl`, restoring the previous binding if it exists. It does nothing if `x` is not bound in `tbl`.

    value do_table : ('a -> 'b -> unit) -> ('a, 'b) t -> unit

  `do_table f tbl` applies `f` to all bindings in table `tbl`, discarding all the results. `f` receives the key as first argument, and the associated value as second argument. Each binding is presented exactly once to `f`. The order in which the bindings are passed to `f` is unpredictable, except that successive bindings for the same key are presented in reverse chronological order (most recent first).

    value do_table_rev : ('a -> 'b -> unit) -> ('a, 'b) t -> unit

  Same as `do_table`, except that successive bindings for the same key are presented in chronological order (oldest first).

### The polymorphic hash primitive

    value hash : 'a -> int

  `hash x` associates a positive integer to any value of any type. It is guaranteed that if `x = y`, then `hash x = hash y`. Moreover, `hash` always terminates, even on cyclic structures.

    value hash_param : int -> int -> 'a -> int

  `hash_param n m x` computes a hash value for `x`, with the same properties as for `hash`. The two extra parameters `n` and `m` give more precise control over hashing. Hashing performs a depth-first, right-to-left traversal of the structure `x`, stopping after `n` meaningful nodes were encountered, or `m` nodes, meaningful or not, were encountered. Meaningful nodes are: integers; floating-point numbers; strings; characters; booleans; and constant constructors. Larger values of `m` and `n` means that more nodes are taken into account to compute the final hash value, and therefore collisions are less likely to happen. However, hashing takes longer. The parameters `m` and `n` govern the tradeoff between accuracy and speed.