package oseq

Empty iterator, with no elements

One-element iterator

Repeat same element endlessly

Cycle through the iterator infinitely. The iterator shouldn't be empty.

# OSeq.(cycle (1--3) |> take 10 |> to_list);;
- : int list = [1; 2; 3; 1; 2; 3; 1; 2; 3; 1]

iterate x f is [x; f x; f (f x); f (f (f x)); ...].

# OSeq.(iterate 0 succ |> take 10 |> to_list);;
- : int list = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9]

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.

# OSeq.(unfold (fun x -> if x<5 then Some (string_of_int x, x+1) else None) 0 |> to_list);;
- : string list = ["0"; "1"; "2"; "3"; "4"]

Call the same function an infinite number of times (useful for instance if the function is a random iterator).

Calls the function, starting from 0, on increasing indices. If n is provided and is a positive int, iteration will stop at the limit (excluded). For instance init ~n:4 (fun x->x) will yield 0, 1, 2, and 3.

Check whether the iterator is empty. Pops an element, if any

Fold on the iterator, tail-recursively.

Alias to fold

Fold on the iterator, tail-recursively.

• since 0.3

Fold on non-empty iterators.

• raises Invalid_argument

  on an empty iterator

Like fold, but keeping successive values of the accumulator.

# OSeq.(scan (+) 0 (1--5) |> to_list);;
- : int list = [0; 1; 3; 6; 10; 15]

A mix of unfold and scan. The current state is combined with the current element to produce a new state, and an output value of type 'c.

Iterate on the iterator .

Iterate on elements with their index in the iterator, from 0.

Length of an iterator (linear time).

Lazy map. No iteration is performed now, the function will be called when the result is traversed.

Lazy map with indexing starting from 0. No iteration is performed now, the function will be called when the result is traversed.

Applicative

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.

Append the two iterators; the result contains the elements of the first, then the elements of the second iterator.

Flatten the iterator of iterators

Monadic bind; each element is transformed to a sub-iterator which is then iterated on, before the next element is processed, and so on.

Is the given element, member of the iterator?

Take at most n elements

Drop n elements

n-th element, or Not_found

• raises Not_found

  if the iterator contains less than n arguments

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.

Take elements while they satisfy the predicate.

Fold elements until ('a, `Stop) is indicated by the accumulator.

Drop elements while they satisfy the predicate.

Maps some elements to 'b, drop the other ones

Zip elements with their index in the iterator

Unzip into two iterators, splitting each pair

partition p l returns the elements that satisfy p, and the elements that do not satisfy p

Is the predicate true for all elements?

Is the predicate true for at least one element?

Minimum element, according to the given comparison function.

• raises Invalid_argument

  if the iterator is empty

Maximum element, see min

• raises Invalid_argument

  if the iterator is empty

Equality of iterators.

Lexicographic comparison of iterators. If a iterator 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.

find_map f e returns the result of f on the first element of e for which it returns Some _, or None otherwise.

• since 0.3

Sum of all elements

Map on the two iterators. Stops once one of them is exhausted.

Iterate on the two iterators. 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 gens (stops when one is exhausted)

Zip together the common part of the gens

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

Merge two sorted iterators into a sorted iterator

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.

interleave a b yields an element of a, then an element of b, and so on. When a iterator is exhausted, this behaves like the other iterator.

Put the separator element between all elements of the given iterator

Cartesian product, in no predictable order. Works even if some of the arguments are infinite.

Cartesian product of three iterators, see product.

• since 0.2

Cartesian product of four iterators, see product.

• since 0.2

Cartesian product of five iterators, see product.

• since 0.2

Cartesian product of six iterators, see product.

• since 0.2

Cartesian product of seven iterators, see product.

• since 0.2

Produce the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. 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.

• since 0.2

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.

• since 0.2

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

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.

Enumerate elements of the list

non tail-call trasnformation to list, in the same order

Tail call conversion to list, in reverse order (more efficient)

Convert the iterator to an array (not very efficient). The iterator must be memoized, as it's traversed twice.

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.

Build a functional iterator from a mutable, imperative generator. Note that the resulting iterator is not going to be really functional because the underlying generator can be consumed only once. Use memoize to recover the proper semantics, or use of_gen directly.

Iterate on bytes of the string

Convert into a string

Traverse the iterator and writes its content to the buffer

concat_string ~sep s concatenates all strings of i, separated with sep. The iterator must be memoized.

• since 0.3

Group together chars belonging to the same line

Explode lines into their chars, adding a '\n' after each one

Pretty print the content of the iterator on a formatter.

Store content of the transient iterator in memory, to be able to iterate on it several times later.

This interface is designed to make it easy to build complex streams of values in a way that resembles Python's generators (using "yield").