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
None is returned when the generator
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.
unit -> 'a option
A generator may be called several times, yielding the next value
each time. It returns
None when no elements remain
module type S =
val get :
'a t -> 'a option
Get the next value
val next :
'a t -> 'a option
val get_exn :
'a t -> 'a
Get the next value, or fails
Invalid_argumentif 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).
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).
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
Gen.Restart directly instead.
val persistent_lazy :
?caching:bool -> ?max_chunk_size:int -> 'a t -> 'a Restart.t
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
val peek :
'a t -> ('a * 'a option) t
peek g transforms the generator
g into a generator
x, Some next if
x was followed by
x, None if
was the last element of
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
Invalid_argumentif the int is
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.