Module type Pqueue.MinPoly

Output signature of the functor MakeMinPoly.

type 'a t

type t('a);

type 'a elt

type elt('a);

val create : unit -> 'a t

let create: unit => t('a);

val length : 'a t -> int

let length: t('a) => int;

val is_empty : 'a t -> bool

let is_empty: t('a) => bool;

val add : 'a t -> 'a elt -> unit

let add: t('a) => elt('a) => unit;

val add_iter : 'a t -> (('a elt -> unit) -> 'x -> unit) -> 'x -> unit

let add_iter: t('a) => ((elt('a) => unit) => 'x => unit) => 'x => unit;

val min_elt : 'a t -> 'a elt option

let min_elt: t('a) => option(elt('a));

val get_min_elt : 'a t -> 'a elt

let get_min_elt: t('a) => elt('a);

val pop_min : 'a t -> 'a elt option

let pop_min: t('a) => option(elt('a));

val remove_min : 'a t -> unit

let remove_min: t('a) => unit;

val clear : 'a t -> unit

let clear: t('a) => unit;

val copy : 'a t -> 'a t

let copy: t('a) => t('a);

val of_array : 'a elt array -> 'a t

let of_array: array(elt('a)) => t('a);

val of_list : 'a elt list -> 'a t

let of_list: list(elt('a)) => t('a);

val of_iter : (('a elt -> unit) -> 'x -> unit) -> 'x -> 'a t

let of_iter: ((elt('a) => unit) => 'x => unit) => 'x => t('a);

val iter_unordered : ('a elt -> unit) -> 'a t -> unit

let iter_unordered: (elt('a) => unit) => t('a) => unit;

val fold_unordered : ('acc -> 'a elt -> 'acc) -> 'acc -> 'a t -> 'acc

let fold_unordered: ('acc => elt('a) => 'acc) => 'acc => t('a) => 'acc;