module Seq: Seqtype'at =unit -> 'a node
The type of delayed lists containing elements of type 'a.
Note that the concrete list node 'a node is delayed under a closure,
not a lazy block, which means it might be recomputed every time
we access it.
type 'a node =
| |
Nil |
| |
Cons of |
A fully-evaluated list node, either empty or containing an element and a delayed tail.
val empty : 'a tThe empty sequence, containing no elements.
val return : 'a -> 'a tThe singleton sequence containing only the given element.
val cons : 'a -> 'a t -> 'a tcons x xs is the sequence containing the element x followed by
the sequence xs
val append : 'a t -> 'a t -> 'a tappend xs ys is the sequence xs followed by the sequence ys
val map : ('a -> 'b) -> 'a t -> 'b tmap f seq returns a new sequence whose elements are the elements of
seq, transformed by f.
This transformation is lazy, it only applies when the result is traversed.
If seq = [1;2;3], then map f seq = [f 1; f 2; f 3].
val filter : ('a -> bool) -> 'a t -> 'a tRemove from the sequence the elements that do not satisfy the given predicate. This transformation is lazy, it only applies when the result is traversed.
val filter_map : ('a -> 'b option) -> 'a t -> 'b tApply the function to every element; if f x = None then x is dropped;
if f x = Some y then y is returned.
This transformation is lazy, it only applies when the result is
traversed.
val concat : 'a t t -> 'a tconcatenate a sequence of sequences.
val flat_map : ('a -> 'b t) -> 'a t -> 'b tMap each element to a subsequence, then return each element of this sub-sequence in turn. This transformation is lazy, it only applies when the result is traversed.
val concat_map : ('a -> 'b t) -> 'a t -> 'b tAlias for Seq.flat_map.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'aTraverse the sequence from left to right, combining each element with the accumulator using the given function. The traversal happens immediately and will not terminate on infinite sequences.
Also see List.fold_left
val iter : ('a -> unit) -> 'a t -> unitIterate on the sequence, calling the (imperative) function on every element. The traversal happens immediately and will not terminate on infinite sequences.
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a tBuild a sequence from a step function and an initial value.
unfold f u returns empty if f u returns None,
or fun () -> Cons (x, unfold f y) if f u returns Some (x, y).
For example, unfold (function [] -> None | h::t -> Some (h,t)) l
is equivalent to List.to_seq l.