sig
  module Array :
    sig
      external length : 'a array -> int = "%array_length"
      external get : 'a array -> int -> 'a = "%array_safe_get"
      external set : 'a array -> int -> '-> unit = "%array_safe_set"
      external make : int -> '-> 'a array = "caml_make_vect"
      external create : int -> '-> 'a array = "caml_make_vect"
      val init : int -> f:(int -> 'a) -> 'a array
      val make_matrix : dimx:int -> dimy:int -> '-> 'a array array
      val create_matrix : dimx:int -> dimy:int -> '-> 'a array array
      val append : 'a array -> 'a array -> 'a array
      val concat : 'a array list -> 'a array
      val sub : 'a array -> pos:int -> len:int -> 'a array
      val copy : 'a array -> 'a array
      val fill : 'a array -> pos:int -> len:int -> '-> unit
      val blit :
        src:'a array ->
        src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
      val to_list : 'a array -> 'a list
      val of_list : 'a list -> 'a array
      val iter : f:('-> unit) -> 'a array -> unit
      val map : f:('-> 'b) -> 'a array -> 'b array
      val iteri : f:(int -> '-> unit) -> 'a array -> unit
      val mapi : f:(int -> '-> 'b) -> 'a array -> 'b array
      val fold_left : f:('-> '-> 'a) -> init:'-> 'b array -> 'a
      val fold_right : f:('-> '-> 'b) -> 'a array -> init:'-> 'b
      val sort : cmp:('-> '-> int) -> 'a array -> unit
      val stable_sort : cmp:('-> '-> int) -> 'a array -> unit
      val fast_sort : cmp:('-> '-> int) -> 'a array -> unit
      external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
      external unsafe_set : 'a array -> int -> '-> unit
        = "%array_unsafe_set"
    end
  module List :
    sig
      val length : 'a list -> int
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val rev : 'a list -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val iter : f:('-> unit) -> 'a list -> unit
      val map : f:('-> 'b) -> 'a list -> 'b list
      val rev_map : f:('-> 'b) -> 'a list -> 'b list
      val fold_left : f:('-> '-> 'a) -> init:'-> 'b list -> 'a
      val fold_right : f:('-> '-> 'b) -> 'a list -> init:'-> 'b
      val iter2 : f:('-> '-> unit) -> 'a list -> 'b list -> unit
      val map2 : f:('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : f:('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        f:('-> '-> '-> 'a) -> init:'-> 'b list -> 'c list -> 'a
      val fold_right2 :
        f:('-> '-> '-> 'c) -> 'a list -> 'b list -> init:'-> 'c
      val for_all : f:('-> bool) -> 'a list -> bool
      val exists : f:('-> bool) -> 'a list -> bool
      val for_all2 : f:('-> '-> bool) -> 'a list -> 'b list -> bool
      val exists2 : f:('-> '-> bool) -> 'a list -> 'b list -> bool
      val mem : '-> set:'a list -> bool
      val memq : '-> set:'a list -> bool
      val find : f:('-> bool) -> 'a list -> 'a
      val filter : f:('-> bool) -> 'a list -> 'a list
      val find_all : f:('-> bool) -> 'a list -> 'a list
      val partition : f:('-> bool) -> 'a list -> 'a list * 'a list
      val assoc : '-> ('a * 'b) list -> 'b
      val assq : '-> ('a * 'b) list -> 'b
      val mem_assoc : '-> map:('a * 'b) list -> bool
      val mem_assq : '-> map:('a * 'b) list -> bool
      val remove_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : '-> ('a * 'b) list -> ('a * 'b) list
      val split : ('a * 'b) list -> 'a list * 'b list
      val combine : 'a list -> 'b list -> ('a * 'b) list
      val sort : cmp:('-> '-> int) -> 'a list -> 'a list
      val stable_sort : cmp:('-> '-> int) -> 'a list -> 'a list
      val fast_sort : cmp:('-> '-> int) -> 'a list -> 'a list
      val merge : cmp:('-> '-> int) -> 'a list -> 'a list -> 'a list
    end
  module type Key = Core_hashtbl.HashedType
  module type S =
    sig
      module Key : Key
      type 'a t
      type 'a container = 'a t
      val length : 'a container -> int
      val is_empty : 'a container -> bool
      val iter : 'a container -> f:('-> unit) -> unit
      val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
      val exists : 'a container -> f:('-> bool) -> bool
      val for_all : 'a container -> f:('-> bool) -> bool
      val find : 'a container -> f:('-> bool) -> 'a option
      val to_list : 'a container -> 'a list
      val to_array : 'a container -> 'a array
      val invariant : 'a t -> unit
      val create : unit -> 'a t
      val clear : 'a t -> unit
      val mem : 'a t -> Key.t -> bool
      val find_opt : 'a t -> Key.t -> 'a option
      val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
      val dequeue : 'a t -> 'a option
      val dequeue_with_key : 'a t -> (Key.t * 'a) option
      val dequeue_all : 'a t -> f:('-> unit) -> unit
      val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
      val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
      val iter_keys : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
      val fold_keys :
        'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
    end
  module Make :
    functor (Key : Key->
      sig
        module Key :
          sig
            type t = Key.t
            val equal : t -> t -> bool
            val hash : t -> int
            val sexp_of_t : t -> Sexplib.Sexp.t
            val t_of_sexp : Sexplib.Sexp.t -> t
          end
        type 'a t = 'Hash_queue.Make(Key).t
        type 'a container = 'a t
        val length : 'a container -> int
        val is_empty : 'a container -> bool
        val iter : 'a container -> f:('-> unit) -> unit
        val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
        val exists : 'a container -> f:('-> bool) -> bool
        val for_all : 'a container -> f:('-> bool) -> bool
        val find : 'a container -> f:('-> bool) -> 'a option
        val to_list : 'a container -> 'a list
        val to_array : 'a container -> 'a array
        val invariant : 'a t -> unit
        val create : unit -> 'a t
        val clear : 'a t -> unit
        val mem : 'a t -> Key.t -> bool
        val find_opt : 'a t -> Key.t -> 'a option
        val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
        val dequeue : 'a t -> 'a option
        val dequeue_with_key : 'a t -> (Key.t * 'a) option
        val dequeue_all : 'a t -> f:('-> unit) -> unit
        val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
        val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
        val iter_keys : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
        val fold_keys :
          'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
      end
end