A sequence xs of type 'a t is a delayed list of elements of type 'a. Such a sequence is queried by performing a function application xs(). This function application returns a node, allowing the caller to determine whether the sequence is empty or nonempty, and in the latter case, to obtain its head and tail.

A node is either Nil, which means that the sequence is empty, or Cons (x, xs), which means that x is the first element of the sequence and that xs is the remainder of the sequence.

find_index p xs returns Some i, where i is the index of the first element of the sequence xs that satisfies p x, if there is such an element.

It returns None if there is no such element.

The sequence xs must be finite.

• since 5.1

Same as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

The sequence xs must be finite.

• since 5.1

This exception is raised when a sequence returned by once (or a suffix of it) is queried more than once.

• since 4.14

The sequence once xs has the same elements as the sequence xs.

Regardless of whether xs is ephemeral or persistent, once xs is an ephemeral sequence: it can be queried at most once. If it (or a suffix of it) is queried more than once, then the exception Forced_twice is raised. This can be useful, while debugging or testing, to ensure that a sequence is consumed at most once.

• raises Forced_twice

  if once xs, or a suffix of it, is queried more than once.

• since 4.14

If xss is a matrix (a sequence of rows), then transpose xss is the sequence of the columns of the matrix xss.

The rows of the matrix xss are not required to have the same length.

The matrix xss is not required to be finite (in either direction).

The matrix xss must be persistent.

• since 4.14

partition_map f xs returns a pair of sequences (ys, zs), where:

• ys is the sequence of the elements y such that f x = Left y, where x ranges over xs;

• zs is the sequence of the elements z such that f x = Right z, where x ranges over xs.

partition_map f xs is equivalent to a pair of filter_map Either.find_left (map f xs) and filter_map Either.find_right (map f xs).

Querying either of the sequences returned by partition_map f xs causes xs to be queried. Therefore, querying both of them causes xs to be queried twice. Thus, xs must be persistent and cheap. If that is not the case, use partition_map f (memoize xs).

• since 4.14

partition p xs returns a pair of the subsequence of the elements of xs that satisfy p and the subsequence of the elements of xs that do not satisfy p.

partition p xs is equivalent to filter p xs, filter (fun x -> not (p x)) xs.

Consuming both of the sequences returned by partition p xs causes xs to be consumed twice and causes the function f to be applied twice to each element of the list. Therefore, f should be pure and cheap. Furthermore, xs should be persistent and cheap. If that is not the case, use partition p (memoize xs).

• since 4.14

of_dispenser it is the sequence of the elements produced by the dispenser it. It is an ephemeral sequence: it can be consumed at most once. If a persistent sequence is needed, use memoize (of_dispenser it).

• since 4.14

to_dispenser xs is a fresh dispenser on the sequence xs.

This dispenser has mutable internal state, which is not protected by a lock; so, it must not be used by several threads concurrently.

• since 4.14

ints i is the infinite sequence of the integers beginning at i and counting up.

• since 4.14

init n f corresponds to the sequence f 0; f 1; ...; f (n-1).

• raises Invalid_argument

  if n is negative.

• since 3.10

repeat ~n x repeats x n times then stops. If n is omitted, then x is repeated forever.

forever f corresponds to the infinite sequence containing all the f ().

• since 3.10

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

iterate f a corresponds to the infinite sequence containing a, f a, f (f a), ...

• since 3.10

unfold f acc calls f acc and:

• if f acc = Some (x, acc'), yield x, continue with unfold f acc'.
• if f acc = None, stops.

is_empty xs checks in the sequence xs is empty

Head of the list.

Unsafe version of head.

• raises Not_found

  if the list is empty.

Tail of the list.

Unsafe version of tail.

• raises Not_found

  if the list is empty.

uncons xs return None if xs is empty other

• since 3.10

Equality step by step. Eager.

Lexicographic comparison. Eager.

Fold on values.

Alias for fold

fold_lefti f init xs applies f acc i x where acc is the result of the previous computation or init for the first one, i is the index in the sequence (starts at 0) and x is the element of the sequence.

• since 3.10

Alias of foldi.

• since 3.10

Iterate with index (starts at 0).

Number of elements in the list. Will not terminate if the list if infinite: use (for instance) take to make the list finite if necessary.

Map with index (starts at 0).

Fair product of two (possibly infinite) lists into a new list. Lazy. The first parameter is used to combine each pair of elements.

Alias of product_with.

• since 3.10

Specialization of product_with producing tuples.

group eq l groups together consecutive elements that satisfy eq. Lazy. For instance group (=) [1;1;1;2;2;3;3;1] yields [1;1;1]; [2;2]; [3;3]; [1].

uniq eq l returns l but removes consecutive duplicates. Lazy. In other words, if several values that are equal follow one another, only the first of them is kept.

for_all p [a1; ...; an] checks if all elements of the sequence satisfy the predicate p. That is, it returns (p a1) && ... && (p an) for a non-empty list and true if the sequence is empty. It consumes the sequence until it finds an element not satisfying the predicate.

• since 3.3

exists p [a1; ...; an] checks if at least one element of the sequence satisfies the predicate p. That is, it returns (p a1) || ... || (p an) for a non-empty sequence and false if the list is empty. It consumes the sequence until it finds an element satisfying the predicate.

• since 3.3

find p [a1; ...; an] return Some ai for the first ai satisfying the predicate p and return None otherwise.

• since 3.10

find f [a1; ...; an] return Some (f ai) for the first ai such that f ai = Some _ and return None otherwise.

• since 3.10

scan f init xs is the sequence containing the intermediate result of fold f init xs.

• since 3.10

Alias of flat_map

• since 3.10

Alias of flatten.

• since 3.10

a -- b is the range of integers containing a and b (therefore, never empty).

a -- b is the integer range from a to b, where b is excluded.

Fold on two collections at once. Stop as soon as one of them ends.

Alias for fold2.

• since 3.10

Map on two collections at once. Stop as soon as one of the arguments is exhausted.

Iterate on two collections at once. Stop as soon as one of them ends.

Merge two sorted iterators into a sorted iterator.

Alias of merge.

• since 3.10

Combine elements pairwise. Stop as soon as one of the lists stops.

Split each tuple in the list.

Alias of unzip.

• since 3.10

zip_i seq zips the index of each element with the element itself.

• since 3.8

Eager sort. Require the iterator to be finite. O(n ln(n)) time and space.

Eager sort that removes duplicate values. Require the iterator to be finite. O(n ln(n)) time and space.

Avoid recomputations by caching intermediate results.

Fair interleaving of both streams.

Fair version of flat_map.

Fair version of (<*>).

Infix version of fair_flat_map.

Infix version of fair_app.

Gather all values into a list.

Iterate on the array.

Convert into array.

Convert to a list, in reverse order. More efficient than to_list.

of_gen g consumes the generator and caches intermediate results.

Iterate on characters.

• since 3.7

pp ~pp_start ~pp_stop ~pp_sep pp_item ppf s formats the sequence s on ppf. Each element is formatted with pp_item, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ ").