## table of contents

- bullseye 4.11.1-4
- testing 4.11.1-5
- unstable 4.11.1-5
- experimental 4.13.1-2

Stdlib.Seq(3o) | OCaml library | Stdlib.Seq(3o) |

# NAME¶

Stdlib.Seq - no description

# Module¶

Module Stdlib.Seq

# Documentation¶

Module **Seq**

: **(module Stdlib__Seq)**

*type* **'a** *t* = **unit -> 'a node**

The type of delayed lists containing elements of type **'a** .
Note that the concrete list node **'a node** is delayed under a closure,
not a **lazy** block, which means it might be recomputed every time we
access it.

*type* **'a** *node* =

| Nil

| Cons **of** **'a * 'a t**

A fully-evaluated list node, either empty or containing an element and a delayed tail.

*val empty* : **'a t**

The empty sequence, containing no elements.

*val return* : **'a -> 'a t**

The singleton sequence containing only the given element.

*val cons* : **'a -> 'a t -> 'a t**

**cons x xs** is the sequence containing the element **x**
followed by the sequence **xs**

**Since** 4.11

*val append* : **'a t -> 'a t -> 'a t**

**append xs ys** is the sequence **xs** followed by the
sequence **ys**

**Since** 4.11

*val map* : **('a -> 'b) -> 'a t -> 'b t**

**map f seq** returns a new sequence whose elements are the
elements of **seq** , transformed by **f** . This transformation is
lazy, it only applies when the result is traversed.

If **seq = [1;2;3]** , then **map f seq = [f 1; f 2; f 3]**
.

*val filter* : **('a -> bool) -> 'a t -> 'a
t**

Remove from the sequence the elements that do not satisfy the given predicate. This transformation is lazy, it only applies when the result is traversed.

*val filter_map* : **('a -> 'b option) -> 'a t ->
'b t**

Apply the function to every element; if **f x = None** then
**x** is dropped; if **f x = Some y** then **y** is returned. This
transformation is lazy, it only applies when the result is traversed.

*val concat* : **'a t t -> 'a t**

concatenate a sequence of sequences.

**Since** 4.13

*val flat_map* : **('a -> 'b t) -> 'a t -> 'b
t**

Map each element to a subsequence, then return each element of this sub-sequence in turn. This transformation is lazy, it only applies when the result is traversed.

*val concat_map* : **('a -> 'b t) -> 'a t -> 'b
t**

Alias for **Seq.flat_map** .

**Since** 4.13

*val fold_left* : **('a -> 'b -> 'a) -> 'a -> 'b
t -> 'a**

Traverse the sequence from left to right, combining each element with the accumulator using the given function. The traversal happens immediately and will not terminate on infinite sequences.

Also see **List.fold_left**

*val iter* : **('a -> unit) -> 'a t -> unit**

Iterate on the sequence, calling the (imperative) function on every element. The traversal happens immediately and will not terminate on infinite sequences.

*val unfold* : **('b -> ('a * 'b) option) -> 'b ->
'a t**

Build a sequence from a step function and an initial value.
**unfold f u** returns **empty** if **f u** returns **None** ,
or **fun () -> Cons (x, unfold f y)** if **f u** returns **Some
(x, y)** .

For example, **unfold (function [] -> None | h::t -> Some
(h,t)) l** is equivalent to **List.to_seq l** .

**Since** 4.11

2021-12-22 | OCamldoc |