# Module Stdlib.Pqueue

    module Pqueue: Pqueue

    module type OrderedType = sig .. end

Input signature of the functors `Pqueue.MakeMin` and `Pqueue.MakeMax`.

    module type Min = sig .. end

Output signature of the functor `Pqueue.MakeMin`.

    module MakeMin: functor (E : OrderedType) -> Min  with type elt := E.t

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

    module type Max = sig .. end

Output signature of the functor `Pqueue.MakeMax`.

    module MakeMax: functor (E : OrderedType) -> Max  with type elt := E.t

Functor building an implementation of the max-priority queue structure given a totally ordered type for elements.

## Polymorphic priority queues

The following, more complex functors create polymorphic queues of type `'a t`, just like other polymorphic containers (lists, arrays...). They require a notion of "polymorphic elements" `'a
elt` that can be compared without depending on the values of `'a`.

One usage scenario is when the user wants to pass priorities separately from the value stored in the queue. This is done by using pairs `priority * 'a` as elements.

          module Prio : OrderedType = ...

          module PrioQueue = Pqueue.MakeMinPoly(struct
            type 'a t = Prio.t * 'a
            let compare (p1, _) (p2, _) = Prio.compare p1 p2
          end)

          (* for example, we now have: *)
          PrioQueue.add: 'a PrioQueue.t -> Prio.t * 'a -> unit
          PrioQueue.min_elt: 'a PrioQueue.t -> (Prio.t * 'a) option

    module type OrderedPolyType = sig .. end

Input signature of the functors `Pqueue.MakeMinPoly` and `Pqueue.MakeMaxPoly`.

    module type MinPoly = sig .. end

Output signature of the functor `Pqueue.MakeMinPoly`.

    module MakeMinPoly: functor (E : OrderedPolyType) -> MinPoly  with type 'a elt := 'a E.t

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

    module type MaxPoly = sig .. end

Output signature of the functor `Pqueue.MakeMaxPoly`.

    module MakeMaxPoly: functor (E : OrderedPolyType) -> MaxPoly  with type 'a elt := 'a E.t

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