Heap implementation based on a pairing-heap.

This heap implementations supports an arbitrary element type, via a comparison function. If you need a heap with elements ordered by integers, then it may be more efficient to use a Timing_wheel.Priority_queue, which is a heap implementation specialized to integer keys, and with some other performance differences and usage restrictions.

include Heap_intf.S
module Removable : sig .. end
Removable augments a heap with the ability to remove elements from the heap in lg(n) (amortized) time at any point after they have been added. Elements within a Removable heap consume 4 words more memory and all heap operations will be somewhat slower.
include Heap_intf.S
module Elt : sig .. end
type 'a t
val value_exn : 'a t -> 'a
value_exn t return the value in the heap controlled by this token if the value is still in the heap. Raise otherwise.
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val add_removable : 'a t -> 'a -> 'a Elt.t
add_removable t v adds v to t, returning a token that can be used to delete v from t in lg(n) amortized time.
val remove : 'a t -> 'a Elt.t -> unit
If t and token are mismatched then behavior is undefined. remove may safely be called on a token more than once. This doesn't free all the memory associated with the Elt until some number of pop operations later -- see Heap_intf for details.
val update : 'a t -> 'a Elt.t -> 'a -> 'a Elt.t
update t token v is shorthand for remove t token; add_removable t v
val find_elt : 'a t -> f:('a -> bool) -> 'a Elt.t option
find_elt t ~f. If f is true for some element in t, return a Elt.t for that element. This operation is O(n).