Library
Module
Module type
Parameter
Class
Class type
OSeq: Functional Iterators
val head_exn : 'a t -> 'a
Returns first element, or fails.
val repeatedly : (unit -> 'a) -> 'a t
Call the same function an infinite number of times (useful for instance if the function is a random iterator).
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
Fold on the iterator, tail-recursively.
val foldi : (int -> 'b -> 'a -> 'b) -> 'b -> 'a t -> 'b
Fold on the iterator, tail-recursively.
val reduce : ('a -> 'a -> 'a) -> 'a t -> 'a
Fold on non-empty iterators.
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. The final accumulator is discarded. Unlike scan
, fold_map does not return the first accumulator.
Same as app
but interleaves the values of the function and the argument iterators. See interleave
for more details.
flat_map_interleave f seq
is similar to flat_map f seq
, except that each sub-sequence is interleaved rather than concatenated in order. See interleave
for more details.
val mem : ('a -> 'a -> bool) -> 'a -> 'a t -> bool
Is the given element, member of the iterator?
val nth : int -> 'a t -> 'a
n-th element, or Not_found
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]
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ]) -> 'a -> 'b t -> 'a
Fold elements until ('a, `Stop
) is indicated by the accumulator.
val min : lt:('a -> 'a -> bool) -> 'a t -> 'a
Minimum element, according to the given comparison function.
val sum : int t -> int
Sum of all elements
Fold the common prefix of the two iterators
Combine common part of the gens (stops when one is exhausted)
Pick elements fairly in each sub-iterator. The merge of gens e1, e2, ...
picks elements in e1
, e2
, in e3
, e1
, e2
.... Once an iterator 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 iterators. Only elements that occur in both inputs appear in the output
Split the iterator into n
iterators in a fair way. Elements with index = k mod n
with go to the k-th iterator. n
default value is 2.
Put the separator element between all elements of the given iterator
Cartesian product of three iterators, see product.
Cartesian product of four iterators, see product.
Cartesian product of five iterators, see product.
Cartesian product of six iterators, see product.
val product7 :
'a t ->
'b t ->
'c t ->
'd t ->
'e t ->
'f t ->
'g t ->
('a * 'b * 'c * 'd * 'e * 'f * 'g) t
Cartesian product of seven iterators, see product.
Produce the cartesian product of this sequence of sequences, by returning all the ways of picking one element per sequence. NOTE the order of the returned sequence is unspecified.
This assumes each sub-sequence is finite, and that the main sequence is also finite.
For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
[[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
# cartesian_product [[1;2];[];[4;5;6]] = [];;
# cartesian_product [[1;2];[3];[4];[5];[6]] |> sort =
[[1;3;4;5;6];[2;3;4;5;6]];;
invariant: cartesian_product l = map_product_l id l
.
map_product_l f l
maps each element of l
to a list of objects of type 'b
using f
. We obtain [l1;l2;...;ln]
where length l=n
and li : 'b list
. Then, it returns all the ways of picking exactly one element per li
.
Remove consecutive duplicate elements. Basically this is like fun e -> map List.hd (group e)
.
Sort according to the given comparison function. The iterator must be finite.
Sort and remove duplicates. The iterator must be finite.
chunks n e
returns a iterator of arrays of length n
, composed of successive elements of e
. The last array may be smaller than n
val permutations : 'a list -> 'a list t
Permutations of the list.
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 iterator (in no particular order). The ordering of the elements within each subset is unspecified.
A type that can be compared and hashed. invariant: for any x
and y
, if equal x y
then hash x=hash y
must hold.
val group_by :
(module HashedType with type t = 'key) ->
project:('a -> 'key) ->
'a t ->
('key * 'a list) t
Group together elements that project onto the same key, ignoring their order of appearance. The order of each resulting list is unspecified.
This function needs to consume the whole input before it can emit anything.
val group_by_fold :
(module HashedType with type t = 'key) ->
project:('a -> 'key) ->
fold:('b -> 'a -> 'b) ->
init:'b ->
'a t ->
('key * 'b) t
Group together elements that project onto the same key, folding them into some aggregate of type 'b
as they are met. This is the most general version of the "group_by" functions.
This function needs to consume the whole input before it can emit anything.
val group_count : (module HashedType with type t = 'a) -> 'a t -> ('a * int) t
Map each distinct element to its number of occurrences in the whole seq. Similar to group_by_fold hash_key ~project:(fun x->x) ~fold:(fun a _->a+1) ~init:0 seq
.
This function needs to consume the whole input before it can emit anything.
val join_by :
(module HashedType with type t = 'key) ->
project_left:('a -> 'key) ->
project_right:('b -> 'key) ->
merge:('key -> 'a -> 'b -> 'c option) ->
'a t ->
'b t ->
'c t
join_by ~project_left ~project_right ~merge a b
takes every pair of elements x
from a
and y
from b
, and if they map onto the same key k
by project_left
and project_right
respectively, and if merge k x y = Some res
, then it yields res
.
If merge k x y
returns None
, the combination of values is discarded.
This function works with infinite inputs, it does not have to consume the whole input before yielding elements.
val join_by_fold :
(module HashedType with type t = 'key) ->
project_left:('a -> 'key) ->
project_right:('b -> 'key) ->
init:'c ->
merge:('key -> 'a -> 'b -> 'c -> 'c) ->
'a t ->
'b t ->
'c t
join_by_fold ~project_left ~project_right ~init ~merge a b
takes every pair of elements x
from a
and y
from b
, and if they map onto the same key k
by project_left
and project_right
respectively, it fold x
and y
into the accumulator for this key (which starts at init
).
This function consumes both inputs entirely before it emits anything.
val of_list : 'a list -> 'a t
Enumerate elements of the list
val to_list : 'a t -> 'a list
non tail-call trasnformation to list, in the same order
val to_rev_list : 'a t -> 'a list
Tail call conversion to list, in reverse order (more efficient)
val to_array : 'a t -> 'a array
Convert the iterator to an array (not very efficient). The iterator must be memoized, as it's traversed twice.
val of_array : ?start:int -> ?len:int -> 'a array -> 'a t
Iterate on (a slice of) the given array
Build a functional iterator from a mutable, imperative generator. The result is properly memoized and can be iterated on several times, as a normal functional value.
val of_string : ?start:int -> ?len:int -> string -> char t
Iterate on bytes of the string
val to_string : char t -> string
Convert into a string
val to_buffer : Stdlib.Buffer.t -> char t -> unit
Traverse the iterator and writes its content to the buffer
val concat_string : sep:string -> string t -> string
concat_string ~sep s
concatenates all strings of i
, separated with sep
. The iterator must be memoized.
module Infix : sig ... end
Pretty print the content of the iterator on a formatter.
module Generator : sig ... end
This interface is designed to make it easy to build complex streams of values in a way that resembles Python's generators (using "yield").
module IO : sig ... end
module type MONAD = sig ... end
include module type of Stdlib.Seq
with type 'a node = 'a Stdlib.Seq.node
and type 'a t := 'a t
val is_empty : 'a t -> bool
val length : 'a t -> int
val iter : ('a -> unit) -> 'a t -> unit
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val iteri : (int -> 'a -> unit) -> 'a t -> unit
val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
val for_all : ('a -> bool) -> 'a t -> bool
val exists : ('a -> bool) -> 'a t -> bool
val find : ('a -> bool) -> 'a t -> 'a option
val find_map : ('a -> 'b option) -> 'a t -> 'b option
val empty : 'a t
val return : 'a -> 'a t
val init : int -> (int -> 'a) -> 'a t
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
val repeat : 'a -> 'a t
val forever : (unit -> 'a) -> 'a t
val iterate : ('a -> 'a) -> 'a -> 'a t
val of_dispenser : (unit -> 'a option) -> 'a t
val to_dispenser : 'a t -> unit -> 'a option
val ints : int -> int t