Page
Library
Module
Module type
Parameter
Class
Class type
Source
Gen_intf.S
SourceDual 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.
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.
Fold on the generator, tail-recursively. Consumes the generator.
Fold on non-empty sequences. Consumes the generator.
Like fold
, but keeping successive values of the accumulator. Consumes the generator.
Iterate on elements with their index in the enum, from 0, consuming it.
Lazy map. No iteration is performed now, the function will be called when the result is traversed.
Append the two enums; the result contains the elements of the first, then the elements of the second enum.
Monadic bind; each element is transformed to a sub-enum which is then iterated on, before the next element is processed, and so on.
Is the given element, member of the enum?
take_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
Filter out elements that do not satisfy the predicate.
Maps some elements to 'b, drop the other ones
partition p l
returns the elements that satisfy p
, and the elements that do not satisfy p
Minimum element, according to the given comparison function.
Lexicographic comparison of generators. If a generator is a prefix of the other one, it is considered smaller.
find p e
returns the first element of e
to satisfy p
, or None.
Map on the two sequences. Stops once one of them is exhausted.
Iterate on the two sequences. Stops once one of them is exhausted.
Fold the common prefix of the two iterators
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.
Combine common part of the enums (stops when one is exhausted)
Pick elements fairly in each sub-generator. The merge of enums 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
.
Intersection of two sorted sequences. Only elements that occur in both inputs appear in the output
Merge two sorted sequences into a sorted sequence
Sorted merge of multiple sorted sequences
Duplicate the enum into n
generators (default 2). The generators share the same underlying instance of the enum, so the optimal case is when they are consumed evenly
Split the enum into n
generators in a fair way. Elements with index = k mod n
with go to the k-th enum. 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.
Put the separator element between all elements of the given enum
Cartesian product, in no predictable order. Works even if some of the arguments are infinite.
Group equal consecutive elements together.
Remove consecutive duplicate elements. Basically this is like fun e -> map List.hd (group e)
.
Sort according to the given comparison function. The enum must be finite.
Sort and remove duplicates. The enum must be finite.
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 enum (in no particular order). The ordering of the elements within each subset is unspecified.
Tail call conversion to list, in reverse order (more efficient)
Iterate on (a slice of) the given array
int_range a b
enumerates integers between a
and b
, included. a
is assumed to be smaller than b
.
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.