Queue(3) OCaml library Queue(3)

# [NAME](#NAME)

Queue - First-in first-out queues.

# [Module](#Module)

Module Queue

# [Documentation](#Documentation)

Module **Queue**  
: **sig end**

First-in first-out queues.

This module implements queues (FIFOs), with in-place modification.

Warning This module is not thread-safe: each **Queue.t** value must be protected from concurrent access (e.g. with a **Mutex.t** ). Failure to do so can lead to a crash.

*type* **'a** *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 **Queue.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.

**Since** 4.08

*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 **Queue.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.

**Since** 4.08

*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 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.

## [Iterators](#Iterators)

*val to\_seq* : **'a t -> 'a Seq.t**

Iterate on the queue, in front-to-back order. The behavior is not specified if the queue is modified during the iteration.

**Since** 4.07

*val add\_seq* : **'a t -> 'a Seq.t -> unit**

Add the elements from a sequence to the end of the queue.

**Since** 4.07

*val of\_seq* : **'a Seq.t -> 'a t**

Create a queue from a sequence.

**Since** 4.07

2026-09-15 OCamldoc

---

Document: Queue(3o) from ocaml-4 4.14.4-r3 (Chainguard OS)
Source: https://github.com/ocaml/ocaml