Library

Module

Module type

Parameter

Class

Class type

## Representation

## Printing

```
val pp :
sep:( Format.formatter -> unit -> unit ) ->
( Format.formatter -> 'a -> unit ) ->
Format.formatter ->
'a t ->
unit
```

Pretty-print a lazy list with items separated by `sep`

. This will traverse the entire list, so printing an infinite or very long list is inadvisable.

## Construction

`val items : 'a list -> 'a t`

`items xs`

is a lazy list consisting of the items in the list `xs`

.

`val of_array : 'a array -> 'a t`

`of_array xs`

is a lazy list consisting of the items in the array `xs`

.

`val unit : 'a -> 'a t`

`unit a`

constructs a lazy list consisting only of the item `a`

.

## Generation

These functions are used to generate lazy lists from specifications.

`val fill : int -> 'a -> 'a t`

`fill n a`

generates a lazy list consisting of `n`

instances of the item `a`

.

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

State-based generation.

Starting with an initial state, generate a new state and a value. Termination is indicated by an outcome of `None`

.

`val iterate : 'a -> ( 'a -> 'a ) -> 'a t`

Generate an infinite lazy list by repeatedly iterating on a value.

`val continually : 'a -> 'a t`

`continually a`

generates an infinite lazy list consisting of the item `a`

.

`val enum_from : int -> int t`

`enum_from z`

generates an infinite lazy list consisting of the integers beginning at `z`

and incremented by one at each step.

`val enum_from_to : int -> int -> int t`

Like `enum_from`

, but the result is a finite lazy list that terminates at the upper bound.

## Manipulation

`val head : 'a t -> 'a option`

The first item in a lazy list, or `None`

if the list is empty.

`take_while f t`

is a lazy list consisting of the first items of `t`

that satisfy the predicate `f`

. The first item in `t`

that does not satisfy the predicate terminates the sequence.

`drop_while f t`

is the lazy list `t`

without the first items that satisfy the predicate `f`

. The first item in `t`

that does not satisfy the predicate terminates the sequence.

`map f t`

is the lazy list `t`

with the `f`

applied to each of its items.

`filter f t`

is the lazy list `t`

with only the items that satisfy the predicate `f`

.

`map_filter f t`

applies `f`

to each element in `t`

and produces a new lazy list consisting of the non-`None`

values.

## Querying

`val exists : ( 'a -> bool ) -> 'a t -> bool`

Check for the existence of an item in the lazy list that satisfies a predicate.

The first item to satisfy the predicate terminates the realization of the list.

`val for_all : ( 'a -> bool ) -> 'a t -> bool`

Check that all items in the lazy list satisfy the predicate.

This requires realizing the entirety of the structure.

`val find : ( 'a -> bool ) -> 'a t -> 'a option`

Return the first item in the lazy list that satisfies the predicate.

## Combining

Combine two lazy lists into a single lazy list, one after the other.

Merge two lazy lists together with a generating function.

Like `zip_with`

, but merge elements from differently sized lazy lists.

Like `zip`

, but merge elements from differently sized lazy lists.

## Folding

`val strict : 'a t -> 'a list`

Realize a lazy list into a strict list.

Fold over a lazy list from the right with an accumulation function.

Since the folding function is lazy in the second argument, evaluation of the lazy list can be short-circuited.

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

Fold over a lazy list from the left with an accumulation function.

`val length : _ t -> int`

The number of elements in the lazy list.

Compare two lazy lists for equality with an element comparison function.

## Iterating

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

`iter f t`

applies the function `f`

to each item in the lazy list. This only makes sense when `f`

performs stateful effects.