module BatQueue:sig..end
This module implements queues (FIFOs), with in-place modification.
Author(s): Xavier Leroy (Base module), David Teller
type'at ='a Queue.t
'a.exception Empty
Queue.take or Queue.peek is applied to an empty queue.val create : unit -> 'a tval add : 'a -> 'a t -> unitadd x q adds the element x at the end of the queue q.val push : 'a -> 'a t -> unitpush is a synonym for add.val take : 'a t -> 'atake q removes and returns the first element in queue q,
or raises Empty if the queue is empty.val pop : 'a t -> 'apop is a synonym for take.val peek : 'a t -> 'apeek q returns the first element in queue q, without removing
it from the queue, or raises Empty if the queue is empty.val top : 'a t -> 'atop is a synonym for peek.val clear : 'a t -> unitval copy : 'a t -> 'a tval is_empty : 'a t -> booltrue if the given queue is empty, false otherwise.val length : 'a t -> intval iter : ('a -> unit) -> 'a t -> unititer f q applies f in turn to all elements of q,
from the least recently entered to the most recently entered.
The queue itself is unchanged.val map : ('a -> 'b) -> 'a t -> 'b tmap f q applies function f to each element of the queue
and returns a new queue q' with the results returned by f.
Order is preserved and q is not consumed. So that if
take q returns x take q' will return f x.val filter : ('a -> bool) -> 'a t -> 'a tfilter p q returns a new queue that contain the elements of q
that satisfy the predicate p, in the same order.val filter_map : ('a -> 'b option) -> 'a t -> 'b tfilter_map f q applies f to the elements a0,a1..an of q in order,
and returns the queue of the elements bi such that f ai = Some bi,
in the corresponding order.val filter_inplace : ('a -> bool) -> 'a t -> unitfilter_inplace p q removes all the elements of the queue q that
don't satisfy the predicate p. The order of the elements
in the queue is preserved.val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'bfold f accu q is equivalent to List.fold_left f accu l,
where l is the list of q's elements. The queue remains
unchanged.val transfer : 'a t -> 'a t -> unittransfer q1 q2 adds all of q1's elements at the end of
the queue q2, then clears q1. It is equivalent to the
sequence iter (fun x -> add x q2) q1; clear q1, but runs
in constant time.type'aenumerable ='a t
val enum : 'a t -> 'a BatEnum.tenum q returns a destructive enumeration of the elements of queue
q, from the least recently entered to the most recently entered.
Reading the enumeration will progressively empty q.val of_enum : 'a BatEnum.t -> 'a tof_enum e returns a new queue containing all the elements of e.
This is equivalent to calling push with the first element of the
enumeration, then with the second, etc.val print : ?first:string ->
?last:string ->
?sep:string ->
('a BatInnerIO.output -> 'b -> unit) ->
'a BatInnerIO.output -> 'b t -> unit
val compare : 'a BatOrd.comp -> 'a t BatOrd.comp
val equal : 'a BatOrd.eq -> 'a t BatOrd.eq
module Exceptionless:sig..end