# 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

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