`module Key : Core_kernel.Hash_queue.Key with type t = t`
`type 'a t`````

A hash-queue, where the values are of type `'a`.

`include sig ... end`
`val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> 'a t ‑> Base.Sexp.t`
`include Core_kernel.Container.S1 with type a t := a t`
`type 'a t`````
`val mem : 'a t ‑> 'a ‑> equal:('a ‑> 'a ‑> bool) ‑> bool`

Checks whether the provided element is there, using `equal`.

`val length : 'a t ‑> int`
`val is_empty : 'a t ‑> bool`
`val iter : 'a t ‑> f:('a ‑> unit) ‑> unit`
`val fold : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> 'accum) ‑> 'accum`

`fold t ~init ~f` returns `f (... f (f (f init e1) e2) e3 ...) en`, where `e1..en` are the elements of `t`

`val fold_result : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.t`

`fold_result t ~init ~f` is a short-circuiting version of `fold` that runs in the `Result` monad. If `f` returns an `Error _`, that value is returned without any additional invocations of `f`.

`val fold_until : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ‑> finish:('accum ‑> 'final) ‑> 'final`

`fold_until t ~init ~f ~finish` is a short-circuiting version of `fold`. If `f` returns `Stop _` the computation ceases and results in that value. If `f` returns `Continue _`, the fold will proceed. If `f` never returns `Stop _`, the final result is computed by `finish`.

`val exists : 'a t ‑> f:('a ‑> bool) ‑> bool`

Returns `true` if and only if there exists an element for which the provided function evaluates to `true`. This is a short-circuiting operation.

`val for_all : 'a t ‑> f:('a ‑> bool) ‑> bool`

Returns `true` if and only if the provided function evaluates to `true` for all elements. This is a short-circuiting operation.

`val count : 'a t ‑> f:('a ‑> bool) ‑> int`

Returns the number of elements for which the provided function evaluates to true.

`val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> 'a t ‑> f:('a ‑> 'sum) ‑> 'sum`

Returns the sum of `f i` for all `i` in the container.

`val find : 'a t ‑> f:('a ‑> bool) ‑> 'a option`

Returns as an `option` the first element for which `f` evaluates to true.

`val find_map : 'a t ‑> f:('a ‑> 'b option) ‑> 'b option`

Returns the first evaluation of `f` that returns `Some`, and returns `None` if there is no such element.

`val to_list : 'a t ‑> 'a list`
`val to_array : 'a t ‑> 'a array`
`val min_elt : 'a t ‑> compare:('a ‑> 'a ‑> int) ‑> 'a option`

Returns a minimum (resp maximum) element from the collection using the provided `compare` function, or `None` if the collection is empty. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses `fold` so it has the same complexity as `fold`.

`val max_elt : 'a t ‑> compare:('a ‑> 'a ‑> int) ‑> 'a option`

`invariant t` checks the invariants of the queue.

`val invariant : 'a t ‑> Core_kernel__.Import.unit`
`val create : ?⁠growth_allowed:Core_kernel__.Import.bool ‑> ?⁠size:Core_kernel__.Import.int ‑> Core_kernel__.Import.unit ‑> 'a t`

`create ()` returns an empty queue. The arguments `growth_allowed` and `size` are referring to the underlying hashtable.

- Parameter growth_allowed: defaults to true
- Parameter size: initial size -- default to 16

`val clear : 'a t ‑> Core_kernel__.Import.unit`

Clears the queue.

### Finding elements

`val mem : 'a t ‑> Key.t ‑> Core_kernel__.Import.bool`

`mem q k` returns true iff there is some (k, v) in the queue.

`val lookup : 'a t ‑> Key.t ‑> 'a Core_kernel__.Import.option`

`lookup t k` returns the value of the key-value pair in the queue with key k, if there is one.

`val lookup_exn : 'a t ‑> Key.t ‑> 'a`

### Adding, removing, and replacing elements

Note that even the non-`*_exn` versions can raise, but only if there is an ongoing iteration.

`val enqueue : 'a t ‑> Key.t ‑> 'a ‑> [ `Ok | `Key_already_present ]`

`enqueue t k v` adds the key-value pair (k, v) to the end of the queue, returning ``Ok` if the pair was added, or ``Key_already_present` if there is already a (k, v') in the queue.

`val enqueue_exn : 'a t ‑> Key.t ‑> 'a ‑> Core_kernel__.Import.unit`
`val lookup_and_move_to_back : 'a t ‑> Key.t ‑> 'a Core_kernel__.Import.option`
`val lookup_and_move_to_back_exn : 'a t ‑> Key.t ‑> 'a`
`val first : 'a t ‑> 'a Core_kernel__.Import.option`

`first t` returns the front element of the queue, without removing it.

`val first_with_key : 'a t ‑> (Key.t * 'a) Core_kernel__.Import.option`

`first_with_key t` returns the front element of the queue and its key, without removing it.

`val keys : 'a t ‑> Key.t Core_kernel__.Import.list`

`keys t` returns the keys in the order of the queue.

`val dequeue : 'a t ‑> 'a Core_kernel__.Import.option`

`dequeue t` returns the front element of the queue.

`val dequeue_exn : 'a t ‑> 'a`
`val dequeue_with_key : 'a t ‑> (Key.t * 'a) Core_kernel__.Import.option`

`dequeue_with_key t` returns the front element of the queue and its key.

`val dequeue_with_key_exn : 'a t ‑> Key.t * 'a`
`val dequeue_all : 'a t ‑> f:('a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unit`

`dequeue_all t ~f` dequeues every element of the queue and applies `f` to each one.

`val remove : 'a t ‑> Key.t ‑> [ `Ok | `No_such_key ]`

`remove q k` removes the key-value pair with key `k` from the queue.

`val remove_exn : 'a t ‑> Key.t ‑> Core_kernel__.Import.unit`
`val replace : 'a t ‑> Key.t ‑> 'a ‑> [ `Ok | `No_such_key ]`

`replace q k v` changes the value of key `k` in the queue to `v`.

`val replace_exn : 'a t ‑> Key.t ‑> 'a ‑> Core_kernel__.Import.unit`

### Iterating over elements

`val iteri : 'a t ‑> f:(key:Key.t ‑> data:'a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unit`

`iter t ~f` applies `f` to each key and element of the queue.

`val foldi : 'a t ‑> init:'b ‑> f:('b ‑> key:Key.t ‑> data:'a ‑> 'b) ‑> 'b`