# Functor Hash_queue.Make

    module Make: functor (Key : Key) -> sig .. end

Parameters:

`Key` | : | `Key`

    module Key: Key

    type 'a t = {

`` | `mutable num_readers : `int`;`
`` | `queue : `'a Key_value.t Doubly_linked.t`;`
`` | `table : `'a Key_value.t Elt.t Table.t`;`

}

    val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t

    val invariant : 'a t -> unit

    val create : ?growth_allowed:bool -> ?size:int -> unit -> 'a t

    val clear : 'a t -> unit

    val length : 'a t -> int

    val is_empty : 'a t -> bool

    val lookup : 'a t -> Table.key Hashtbl.key -> 'a option

    val lookup_exn : 'a t -> Table.key Hashtbl.key -> 'a

    val mem : 'a t -> Table.key Hashtbl.key -> bool

    val to_list : 'a t -> 'a List.t

    val to_array : 'a t -> 'a Array.t

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

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

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

    val find : 'a t -> f:('a -> bool) -> 'a Option.t

    val enqueue : 'a t ->
           Table.key Hashtbl.key ->
           'a -> [> `Key_already_present | `Ok ]

    val enqueue_exn : 'a t -> Table.key Hashtbl.key -> 'a -> unit

    val dequeue_with_key : 'a t -> (Key.t * 'a) option

    val dequeue_with_key_exn : 'a t -> Key.t * 'a

    val dequeue : 'a t -> 'a option

    val first_with_key : 'a t -> (Key.t * 'a) option

    val first : 'a t -> 'a option

    val dequeue_exn : 'a t -> 'a

    val keys : 'a t -> Key.t List.t

    val iteri : 'a t ->
           f:(key:Key.t -> data:'a -> unit) -> unit

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

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

    val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b

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

    val sum : (module Commutative_group.S with type t = 'a) ->
           'b t -> f:('b -> 'a) -> 'a

    val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option

    val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option

    val dequeue_all : 'a t -> f:('a -> 'b) -> unit

    val remove : 'a t ->
           Table.key Hashtbl.key -> [> `No_such_key | `Ok ]

    val remove_exn : 'a t -> Table.key Hashtbl.key -> unit

    val replace : 'a t ->
           Table.key Hashtbl.key -> 'a -> [> `No_such_key | `Ok ]

    val replace_exn : 'a t -> Table.key Hashtbl.key -> 'a -> unit