Module Gen

module Gen: sig .. end

Generators

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.



Global type declarations


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

Transient generators


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

Restartable 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

Utils


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.

Basic IO

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

module IO: sig .. end