# Module `Stdlib.Seq`

## Functional Iterators

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

`and +'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 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 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 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.