# Stdlib.Seq.3o - Man Page

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