# Module Stdlib.Seq

`module Seq: `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``
• 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