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 : ('b -> Element.t -> 'b) -> '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 -> 'a t -> 'a t
val merge : 'a t -> 'a t -> 'a t
val iterate : (Key.t * 'a -> unit) -> 'a t -> unit
val predicate : (Key.t * 'a -> bool) -> 'a t -> bool
val fold : ('b -> Key.t * 'a -> 'b) -> 'b -> 'a t -> 'b
val filter : (Key.t * 'a -> bool) -> 'a t -> 'a t
val map : (Key.t * 'a -> 'b) -> 'a t -> 'b t
val optmap : (Key.t * 'a -> 'b option) -> 'a t -> 'b t
val partition : (Key.t * 'a -> 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