First-in first-out queues.
This module implements queues (FIFOs), with in-place modification.
type 'a t = 'a Queue.tThe type of queues containing elements of type 'a.
Raised when Queue.take or Queue.peek is applied to an empty queue.
val create : unit -> 'a tReturn a new queue, initially empty.
val 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 -> unitDiscard all elements from a queue.
val is_empty : 'a t -> boolReturn true if the given queue is empty, false otherwise.
val length : 'a t -> intReturn the number of elements in a queue.
val 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.
map 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.
filter p q returns a new queue that contain the elements of q that satisfy the predicate p, in the same order.
filter_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.
transfer 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 'a enumerable = 'a 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.
of_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 ->
unitval compare : 'a BatOrd.comp -> 'a t BatOrd.compmodule Exceptionless : sig ... end