Date.Hash_queueSourceinclude Container.S1_phantom
with type ('data, 'key) t := ('key, 'data) Hash_queue.tfold 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) Hash_queue.t ->
init:'acc ->
f:('acc -> 'a -> ('acc, 'e) Base.Result.t) ->
('acc, '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) Hash_queue.t ->
init:'acc ->
f:('acc -> 'a -> ('acc, 'final) Base.Container.Continue_or_stop.t) ->
finish:('acc -> 'final) ->
'finalfold_until t ~init ~f ~finish 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. If f never returns Stop _, the final result is computed by finish.
Example:
type maybe_negative =
| Found_negative of int
| All_nonnegative of { sum : int }
(** [first_neg_or_sum list] returns the first negative number in [list], if any,
otherwise returns the sum of the list. *)
let first_neg_or_sum =
List.fold_until ~init:0
~f:(fun sum x ->
if x < 0
then Stop (Found_negative x)
else Continue (sum + x))
~finish:(fun sum -> All_nonnegative { sum })
;;
let x = first_neg_or_sum [1; 2; 3; 4; 5]
val x : maybe_negative = All_nonnegative {sum = 15}
let y = first_neg_or_sum [1; 2; -3; 4; 5]
val y : maybe_negative = Found_negative -3Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
Returns the number of elements for which the provided function evaluates to true.
val sum :
(module Base.Container.Summable with type t = 'sum) ->
(_, 'a) Hash_queue.t ->
f:('a -> 'sum) ->
'sumReturns the sum of f i for all i in the container.
Returns as an option the first element for which f evaluates to true.
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
Returns a min (resp max) element from the collection using the provided compare function. 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. Returns None iff the collection is empty.
invariant t checks the invariants of the queue.
val create :
?growth_allowed:Base.Bool.t ->
?size:Base.Int.t ->
Base.Unit.t ->
(key, 'data) Hash_queue.tcreate () returns an empty queue. The arguments growth_allowed and size are referring to the underlying hashtable.
Clears the queue.
Makes a fresh copy of the queue with identical contents to the original.
mem q k returns true iff there is some (k, v) in the queue.
lookup 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.
val enqueue :
('key, 'data) Hash_queue.t ->
[ `back | `front ] ->
'key ->
'data ->
[ `Ok | `Key_already_present ]enqueue t back_or_front k v adds the key-value pair (k, v) to the front or back 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 :
('key, 'data) Hash_queue.t ->
[ `back | `front ] ->
'key ->
'data ->
Base.Unit.tLike enqueue, but it raises in the `Key_already_present case
val enqueue_back :
('key, 'data) Hash_queue.t ->
'key ->
'data ->
[ `Ok | `Key_already_present ]See enqueue. enqueue_back t k v is the same as enqueue t `back k v
See enqueue_exn. enqueue_back_exn t k v is the same as enqueue_exn t `back k v
val enqueue_front :
('key, 'data) Hash_queue.t ->
'key ->
'data ->
[ `Ok | `Key_already_present ]See enqueue. enqueue_front t k v is the same as enqueue t `front k v
See enqueue_exn. enqueue_front_exn t k v is the same as enqueue_exn t `front k v
lookup_and_move_to_back finds the key-value pair (k, v) and moves it to the back of the queue if it exists, otherwise returning None.
The _exn versions of these functions raise if key-value pair does not exist.
Like lookup_and_move_to_back, but raises instead of returning an option
Like lookup_and_move_to_back, but moves element to the front of the queue
Like lookup_and_move_to_front, but raises instead of returning an option
last t returns the last element of the queue, without removing it.
last_with_key t returns the last element of the queue and its key, without removing it.
first t returns the front element of the queue, without removing it.
first_with_key t returns the front element of the queue and its key, without removing it.
keys t returns the keys in the order of the queue.
to_alist t returns the elements of the queue with their keys in the order of the queue.
dequeue t front_or_back returns the front or back element of the queue.
Like dequeue, but it raises if the queue is empty.
dequeue_back t returns the back element of the queue.
Like dequeue_back, but it raises if the queue is empty.
dequeue_front t returns the front element of the queue.
Like dequeue_front, but it raises if the queue is empty.
val dequeue_with_key :
('key, 'data) Hash_queue.t ->
[ `back | `front ] ->
('key * 'data) Base.Option.tdequeue_with_key t returns the front or back element of the queue and its key.
Like dequeue_with_key, but it raises if the queue is empty.
dequeue_back_with_key t returns the back element of the queue and its key.
Like dequeue_back_with_key, but it raises if the queue is empty.
dequeue_front_with_key t returns the front element of the queue and its key.
Like dequeue_front_with_key, but it raises if the queue is empty.
dequeue_all t ~f dequeues every element of the queue and applies f to each one. The dequeue order is from front to back.
remove q k removes the key-value pair with key k from the queue.
like remove, but returns the removed element
replace q k v changes the value of key k in the queue to v.
val replace_or_enqueue :
('key, 'data) Hash_queue.t ->
[ `back | `front ] ->
'key ->
'data ->
Base.Unit.treplace_or_enqueue q back_or_front k v changes the value of key k in the queue to v. If the key k does not exist in the queue, it is added to the front or back with the value v.
See replace_or_enqueue. replace_or_enqueue_front t k v is the same as replace_or_enqueue t `front k v
See replace_or_enqueue. replace_or_enqueue_back t k v is the same as replace_or_enqueue t `back k v
drop ?n q back_or_front drops n elements (default 1) from the back or front of the queue. If the queue has fewer than n elements then it is cleared.
Equivalent to drop ?n q `front.
Equivalent to drop ?n q `back.
val iteri :
('key, 'data) Hash_queue.t ->
f:(key:'key -> data:'data -> Base.Unit.t) ->
Base.Unit.titer t ~f applies f to each key and element of the queue.
val foldi :
('key, 'data) Hash_queue.t ->
init:'acc ->
f:('acc -> key:'key -> data:'data -> 'acc) ->
'acc