Module BatQueue

module BatQueue: sig .. end
First-in first-out queues.

This module implements queues (FIFOs), with in-place modification.
Author(s): Xavier Leroy (Base module), David Teller

type 'a t = 'a Queue.t 
The type of queues containing elements of type 'a.
exception Empty
Raised when Queue.take or Queue.peek is applied to an empty queue.
val create : unit -> 'a t
Return a new queue, initially empty.
val add : 'a -> 'a t -> unit
add x q adds the element x at the end of the queue q.
val push : 'a -> 'a t -> unit
push is a synonym for add.
val take : 'a t -> 'a
take q removes and returns the first element in queue q, or raises Empty if the queue is empty.
val pop : 'a t -> 'a
pop is a synonym for take.
val peek : 'a t -> 'a
peek 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 -> 'a
top is a synonym for peek.
val clear : 'a t -> unit
Discard all elements from a queue.
val copy : 'a t -> 'a t
Return a copy of the given queue.
val is_empty : 'a t -> bool
Return true if the given queue is empty, false otherwise.
val length : 'a t -> int
Return the number of elements in a queue.
val iter : ('a -> unit) -> 'a t -> unit
iter 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 t
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.
Since 2.3.0
val filter : ('a -> bool) -> 'a t -> 'a t
filter p q returns a new queue that contain the elements of q that satisfy the predicate p, in the same order.
Since 2.4
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
filter_map f q applies f to the elements a0, of q in order, and returns the queue of the elements bi such that f ai = Some bi, in the corresponding order.
Since 2.4
val filter_inplace : ('a -> bool) -> 'a t -> unit
filter_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.
Since 2.4
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
fold 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 -> unit
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 t 
val enum : 'a t -> 'a BatEnum.t
enum 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 t
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.

Boilerplate code


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