module BatQueue:sig
..end
First-in first-out queues.
This module implements queues (FIFOs), with in-place modification.
type'a
t ='a Stdlib.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 take_opt : 'a t -> 'a option
take_opt q
removes and returns the first element in queue q
,
or returns None
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 peek_opt : 'a t -> 'a option
peek_opt q
returns the first element in queue q
, without removing
it from the queue, or returns None
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
.
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.
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
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 -> 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.
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.
val to_seq : 'a t -> 'a Stdlib.Seq.t
Iterate on the queue, in front-to-back order. The behavior is not defined if the queue is modified during the iteration.
val add_seq : 'a t -> 'a Stdlib.Seq.t -> unit
Add the elements from the generator to the end of the queue
val of_seq : 'a Stdlib.Seq.t -> 'a t
Create a queue from the generator
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