Module Pqueue.MakeMinPoly

Functor building an implementation of min-priority queues given a totally ordered type for the elements.

Parameters

module E : OrderedPolyType

module E: OrderedPolyType

Signature

type 'a t

type t('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 E.t -> unit

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

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

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

val min_elt : 'a t -> 'a E.t option

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

val get_min_elt : 'a t -> 'a E.t

let get_min_elt: t('a) => E.t('a);

val pop_min : 'a t -> 'a E.t option

let pop_min: t('a) => option(E.t('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 E.t array -> 'a t

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

val of_list : 'a E.t list -> 'a t

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

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

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

val iter_unordered : ('a E.t -> unit) -> 'a t -> unit

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

val fold_unordered : ('acc -> 'a E.t -> 'acc) -> 'acc -> 'a t -> 'acc

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