module Key : Core_kernel.Hash_queue.Key with type t = tinclude sig ... endval sexp_of_t : ('a ‑> Sexplib.Sexp.t) ‑> 'a t ‑> Sexplib.Sexp.tinclude Core_kernel.Container.S1 with type a t := a tval mem : 'a t ‑> 'a ‑> equal:('a ‑> 'a ‑> bool) ‑> boolChecks whether the provided element is there, using equal.
val length : 'a t ‑> intval is_empty : 'a t ‑> boolval iter : 'a t ‑> f:('a ‑> unit) ‑> unitval fold : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> 'accum) ‑> 'accumfold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en
are the elements of t
val fold_result : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.tfold_result t ~init ~f is a short-circuiting version of fold that runs in the
Result monad. If f returns an Error _, that value is returned without any
additional invocations of f.
val fold_until : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ‑> ('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.tfold_until t ~init ~f is a short-circuiting version of fold. If f
returns Stop _ the computation ceases and results in that value. If f returns
Continue _, the fold will proceed.
val exists : 'a t ‑> f:('a ‑> bool) ‑> boolReturns true if and only if there exists an element for which the provided
function evaluates to true. This is a short-circuiting operation.
val for_all : 'a t ‑> f:('a ‑> bool) ‑> boolReturns true if and only if the provided function evaluates to true for all
elements. This is a short-circuiting operation.
val count : 'a t ‑> f:('a ‑> bool) ‑> intReturns the number of elements for which the provided function evaluates to true.
val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> 'a t ‑> f:('a ‑> 'sum) ‑> 'sumReturns the sum of f i for all i in the container.
val find : 'a t ‑> f:('a ‑> bool) ‑> 'a optionReturns as an option the first element for which f evaluates to true.
val find_map : 'a t ‑> f:('a ‑> 'b option) ‑> 'b optionReturns the first evaluation of f that returns Some, and returns None if there
is no such element.
val to_list : 'a t ‑> 'a listval to_array : 'a t ‑> 'a arrayval min_elt : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a optionReturns a minimum (resp maximum) element from the collection using the provided
cmp function, or None if the collection is empty. In case of a tie, the first
element encountered while traversing the collection is returned. The implementation
uses fold so it has the same complexity as fold.
val max_elt : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a optioninvariant t checks the invariants of the queue.
val invariant : 'a t ‑> Core_kernel__.Import.unitval create : ?growth_allowed:Core_kernel__.Import.bool ‑> ?size:Core_kernel__.Import.int ‑> Core_kernel__.Import.unit ‑> 'a tcreate () returns an empty queue. The arguments growth_allowed and size are
referring to the underlying hashtable.
val mem : 'a t ‑> Key.t ‑> Core_kernel__.Import.boolmem q k returns true iff there is some (k, v) in the queue.
val lookup : 'a t ‑> Key.t ‑> 'a Core_kernel__.Import.optionlookup t k returns the value of the key-value pair in the queue with
key k, if there is one.
Note that even the non-*_exn versions can raise, but only if there is an ongoing
iteration.
enqueue t k v adds the key-value pair (k, v) to the end of the queue, returning
`Ok if the pair was added, or `Key_already_present if there is already a (k, v')
in the queue.
val enqueue_exn : 'a t ‑> Key.t ‑> 'a ‑> Core_kernel__.Import.unitval lookup_and_move_to_back : 'a t ‑> Key.t ‑> 'a Core_kernel__.Import.optionval first : 'a t ‑> 'a Core_kernel__.Import.optionfirst t returns the front element of the queue, without removing it.
val first_with_key : 'a t ‑> (Key.t * 'a) Core_kernel__.Import.optionfirst_with_key t returns the front element of the queue and its key, without
removing it.
val keys : 'a t ‑> Key.t Core_kernel__.Import.listkeys t returns the keys in the order of the queue.
val dequeue : 'a t ‑> 'a Core_kernel__.Import.optiondequeue t returns the front element of the queue.
val dequeue_exn : 'a t ‑> 'aval dequeue_with_key : 'a t ‑> (Key.t * 'a) Core_kernel__.Import.optiondequeue_with_key t returns the front element of the queue and its key.
val dequeue_all : 'a t ‑> f:('a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unitdequeue_all t ~f dequeues every element of the queue and applies f to each one.
val remove_exn : 'a t ‑> Key.t ‑> Core_kernel__.Import.unitval replace_exn : 'a t ‑> Key.t ‑> 'a ‑> Core_kernel__.Import.unitval iteri : 'a t ‑> f:(key:Key.t ‑> data:'a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unititer t ~f applies f to each key and element of the queue.