Module GenLabels

module GenLabels: sig .. end


Label version of Gen

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

Transient generators

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

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

Restartable 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.

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

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

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