Seq(3o) OCaml library Seq(3o)
NAME
Seq - Sequences (functional iterators).
Module
Module Seq
Documentation
Module Seq
: sig end
Sequences (functional iterators).
The type 'a Seq.t is a delayed list, i.e. a list where some evaluation
is needed to access the next element. This makes it possible to build
infinite sequences, to build sequences as we traverse them, and to
transform them in a lazy fashion rather than upfront.
Since 4.07
type 'a t = 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 * 'a t
A fully-evaluated list node, either empty or containing an element and
a delayed tail.
val empty : 'a t
The empty sequence, containing no elements.
val return : 'a -> 'a t
The singleton sequence containing only the given element.
val cons : 'a -> 'a t -> 'a t
cons x xs is the sequence containing the element x followed by the se-
quence xs
Since 4.11
val append : 'a t -> 'a t -> 'a t
append xs ys is the sequence xs followed by the sequence ys
Since 4.11
val map : ('a -> 'b) -> 'a t -> 'b t
map 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 t
Remove from the sequence the elements that do not satisfy the given
predicate. This transformation is lazy, it only applies when the re-
sult is traversed.
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
Apply 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 t
concatenate a sequence of sequences.
Since 4.13
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
Map 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 t
Alias for Seq.flat_map .
Since 4.13
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Traverse the sequence from left to right, combining each element with
the accumulator using the given function. The traversal happens imme-
diately and will not terminate on infinite sequences.
Also see List.fold_left
val iter : ('a -> unit) -> 'a t -> unit
Iterate on the sequence, calling the (imperative) function on every el-
ement. The traversal happens immediately and will not terminate on in-
finite sequences.
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
Build 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 .
Since 4.11
OCamldoc 2023-02-12 Seq(3o)
Generated by dwww version 1.15 on Sat Jun 22 16:31:11 CEST 2024.