module GenLabels:`sig`

..`end`

Label version of `Gen`

**Since**0.2.4

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 = ``GenLabels_intf.S`

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

Get the next value

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

Synonym for `GenLabels.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 GenLabels.S`

Operations on **transient** generators

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

directly instead.

`val persistent_lazy : ``?caching:bool ->`

?max_chunk_size:int -> 'a t -> 'a Restart.t

Same as `GenLabels.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 : ``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`