sig
  module Heap :
    functor (E : Cf_ordered.Total_T->
      sig
        type t
        module Element : sig type t = E.t val compare : t -> t -> int end
        val nil : t
        val empty : t -> bool
        val size : t -> int
        val head : t -> Element.t
        val tail : t -> t
        val pop : t -> (Element.t * t) option
        val put : Element.t -> t -> t
        val merge : t -> t -> t
        val iterate : (Element.t -> unit) -> t -> unit
        val predicate : (Element.t -> bool) -> t -> bool
        val fold : ('-> Element.t -> 'b) -> '-> t -> 'b
        val filter : (Element.t -> bool) -> t -> t
        val partition : (Element.t -> bool) -> t -> t * t
        val of_seq : Element.t Cf_seq.t -> t
        val of_list : Element.t list -> t
        val to_seq : t -> Element.t Cf_seq.t
        val to_seq2 : t -> (Element.t * t) Cf_seq.t
      end
  module PQueue :
    functor (K : Cf_ordered.Total_T->
      sig
        type +'a t
        module Key : sig type t = K.t val compare : t -> t -> int end
        val nil : 'a t
        val empty : 'a t -> bool
        val size : 'a t -> int
        val head : 'a t -> Key.t * 'a
        val tail : 'a t -> 'a t
        val pop : 'a t -> ((Key.t * 'a) * 'a t) option
        val put : Key.t * '-> 'a t -> 'a t
        val merge : 'a t -> 'a t -> 'a t
        val iterate : (Key.t * '-> unit) -> 'a t -> unit
        val predicate : (Key.t * '-> bool) -> 'a t -> bool
        val fold : ('-> Key.t * '-> 'b) -> '-> 'a t -> 'b
        val filter : (Key.t * '-> bool) -> 'a t -> 'a t
        val map : (Key.t * '-> 'b) -> 'a t -> 'b t
        val optmap : (Key.t * '-> 'b option) -> 'a t -> 'b t
        val partition : (Key.t * '-> bool) -> 'a t -> 'a t * 'a t
        val of_seq : (Key.t * 'a) Cf_seq.t -> 'a t
        val of_list : (Key.t * 'a) list -> 'a t
        val to_seq : 'a t -> (Key.t * 'a) Cf_seq.t
        val to_seq2 : 'a t -> ((Key.t * 'a) * 'a t) Cf_seq.t
      end
end