module Gen:`sig`

..`end`

Values of type `'a Gen.t`

represent a possibly infinite sequence of values
of type 'a. One can only iterate once on the sequence, as it is consumed
by iteration/deconstruction/access. `None`

is returned when the generator
is exhausted.

The submodule `Gen.Restart`

provides utilities to work with
**restartable generators**, that is, functions `unit -> 'a Gen.t`

that
allow to build as many generators from the same source as needed.

type`'a`

t =`unit -> 'a option`

A generator may be called several times, yielding the next value
each time. It returns `None`

when no elements remain

type`'a`

gen =`'a t`

`module type S = ``Gen_intf.S`

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

Get the next value

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

Synonym for `Gen.get`

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

Get the next value, or fails

**Raises**`Invalid_argument`

if no element remains

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

Drop the next value, discarding it.

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

Call the same function an infinite number of times (useful for instance if the function is a random generator).

`include Gen.S`

Operations on **transient** generators

A *restartable generator* is a function that produces copies of the
same generator, on demand. It has the type `unit -> 'a gen`

and it is
assumed that every generated returned by the function behaves the same
(that is, that it traverses the same sequence of elements).

module Restart:`sig`

..`end`

`val persistent : ``'a t -> 'a Restart.t`

Store content of the transient generator in memory, to be able to iterate
on it several times later. If possible, consider using combinators
from `Gen.Restart`

directly instead.

`val persistent_lazy : ``?caching:bool -> ?max_chunk_size:int -> 'a t -> 'a Restart.t`

Same as `Gen.persistent`

, but consumes the generator on demand (by chunks).
This allows to make a restartable generator out of an ephemeral one,
without paying a big cost upfront (nor even consuming it fully).
Optional parameters: see `GenMList.of_gen_lazy`

.

**Since**0.2.2

`val peek : ``'a t -> ('a * 'a option) t`

`peek g`

transforms the generator `g`

into a generator
of `x, Some next`

if `x`

was followed by `next`

in `g`

, or `x, None`

if `x`

was the last element of `g`

**Since**0.4

`val peek_n : ``int -> 'a t -> ('a * 'a array) t`

`peek_n n g`

iterates on `g`

, returning along with each element
the array of the (at most) `n`

elements that follow it immediately

**Since**0.4**Raises**`Invalid_argument`

if the int is`< 1`

`val start : ``'a Restart.t -> 'a t`

Create a new transient generator.
`start gen`

is the same as `gen ()`

but is included for readability.

Very basic interface to manipulate files as sequence of chunks/lines.

module IO:`sig`

..`end`