A simple polymorphic functional queue. Use this data structure for strictly first-in,
first-out access to a sequence of values. For a similar data structure with enqueue
and dequeue accessors on both ends of a sequence, see
Amortized running times assumes that enqueue/dequeue are used sequentially, threading the changing Fqueue through the calls.
Checks whether the provided element is there, using polymorphic compare if
is not provided
fold t ~init ~f returns
f (... f (f (f init e1) e2) e3 ...) en, where
are the elements of
true if and only if there exists an element for which the provided
function evaluates to
true. This is a short-circuiting operation.
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.
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 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
fold so it has the same complexity as
The empty queue
returns the bottom (most-recently enqueued element). Raises
Empty if no element is
found. Complexity: O(1)
bot_exn is deprecated, use
bot_exn, but returns result optionally, without exception. Complexity: O(1)
bot is deprecated, use
bot_exn, except returns top (least-recently enqueued element. Complexity:
top_exn, but returns result optionally, without exception, Complexity: O(1)
to_list t returns a list of the elements in
t in order from least-recently-added
(at the head) to most-recently added (at the tail). Complexity: O(n)