Label version of Gen
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
module type S = GenLabels_intf.S
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
include S with type 'a S.t := 'a gen
val unfold : ('b ‑> ('a * 'b) option) ‑> 'b ‑> 'a t
Dual of fold, with a deconstructing operation. It keeps on
unfolding the 'b
value into a new 'b
, and a 'a
which is yielded,
until None
is returned.
val init : ?limit:int ‑> (int ‑> 'a) ‑> 'a t
Calls the function, starting from 0, on increasing indices.
If limit
is provided and is a positive int, iteration will
stop at the limit (excluded).
For instance init ~limit:4 id
will yield 0, 1, 2, and 3.
Note: those combinators, applied to generators (not restartable
generators) consume their argument. Sometimes they consume it lazily,
sometimes eagerly, but in any case once f gen
has been called (with f
a
combinator), gen
shouldn't be used anymore.
val fold : f:('b ‑> 'a ‑> 'b) ‑> init:'b ‑> 'a t ‑> 'b
Fold on the generator, tail-recursively. Consumes the generator.
val reduce : f:('a ‑> 'a ‑> 'a) ‑> 'a t ‑> 'a
Fold on non-empty sequences. Consumes the generator.
Like fold, but keeping successive values of the accumulator. Consumes the generator.
val iteri : f:(int ‑> 'a ‑> unit) ‑> 'a t ‑> unit
Iterate on elements with their index in the gen, from 0, consuming it.
Lazy map with indexing starting from 0. No iteration is performed now, the function will be called when the result is traversed.
Lazy fold and map. No iteration is performed now, the function will be called when the result is traversed. The result is an iterator over the successive states of the fold.
Append the two gens; the result contains the elements of the first, then the elements of the second gen.
val flat_map : f:('a ‑> 'b GenLabels_intf.gen) ‑> 'a t ‑> 'b t
Monadic bind; each element is transformed to a sub-gen which is then iterated on, before the next element is processed, and so on.
val nth : int ‑> 'a t ‑> 'a
n-th element, or Not_found
n
argumentstake_nth n g
returns every element of g
whose index
is a multiple of n
. For instance take_nth 2 (1--10) |> to_list
will return 1;3;5;7;9
Take elements while they satisfy the predicate. The initial generator itself is not to be used anymore after this.
val fold_while : f:('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> init:'a ‑> 'b t ‑> 'a
Fold elements until ('a, `Stop
) is indicated by the accumulator.
Drop elements while they satisfy the predicate. The initial generator
itself should not be used anymore, only the result of drop_while
.
val min : ?lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a
Minimum element, according to the given comparison function.
val max : ?lt:('a ‑> 'a ‑> bool) ‑> 'a t ‑> 'a
Maximum element, see min
Lexicographic comparison of generators. If a generator is a prefix of the other one, it is considered smaller.
val find : f:('a ‑> bool) ‑> 'a t ‑> 'a option
find p e
returns the first element of e
to satisfy p
,
or None.
Succeeds if all pairs of elements satisfy the predicate. Ignores elements of an iterator if the other runs dry.
Succeeds if some pair of elements satisfy the predicate. Ignores elements of an iterator if the other runs dry.
val merge : 'a GenLabels_intf.gen t ‑> 'a t
Pick elements fairly in each sub-generator. The merge of gens
e1, e2, ...
picks elements in e1
, e2
,
in e3
, e1
, e2
.... Once a generator is empty, it is skipped;
when they are all empty, and none remains in the input,
their merge is also empty.
For instance, merge [1;3;5] [2;4;6]
will be, in disorder, 1;2;3;4;5;6
.
val tee : ?n:int ‑> 'a t ‑> 'a GenLabels_intf.gen list
Duplicate the gen into n
generators (default 2). The generators
share the same underlying instance of the gen, so the optimal case is
when they are consumed evenly
val round_robin : ?n:int ‑> 'a t ‑> 'a GenLabels_intf.gen list
Split the gen into n
generators in a fair way. Elements with
index = k mod n
with go to the k-th gen. n
default value
is 2.
interleave a b
yields an element of a
, then an element of b
,
and so on. When a generator is exhausted, this behaves like the
other generator.
chunks n e
returns a generator of arrays of length n
, composed
of successive elements of e
. The last array may be smaller
than n
Combinations of given length. The ordering of the elements within
each combination is unspecified.
Example (ignoring ordering):
combinations 2 (1--3) |> to_list = [[1;2]; [1;3]; [2;3]]
All subsets of the gen (in no particular order). The ordering of the elements within each subset is unspecified.
val int_range : ?step:int ‑> int ‑> int ‑> int t
int_range ~step a b
generates integers between a
and b
, included,
with steps of length step
(1 if omitted). a
is assumed to be smaller
than b
. step
must not be null, but it can be negative for decreasing
integers.
module Infix : sig ... end
val pp : ?start:string ‑> ?stop:string ‑> ?sep:string ‑> ?horizontal:bool ‑> (Format.formatter ‑> 'a ‑> unit) ‑> Format.formatter ‑> 'a t ‑> unit
Pretty print the content of the generator on a formatter.
module Restart : sig ... end
Store content of the transient generator in memory, to be able to iterate on it several times later. If possible, consider using combinators from Restart directly instead.
Same as 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.
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
peek_n ~n g
iterates on g
, returning along with each element
the array of the (at most) n
elements that follow it immediately
< 1
Very basic interface to manipulate files as sequence of chunks/lines.
module IO : sig ... end