Module Traced.Seq

include Bare_sigs.Seq.S

Common interface with Stdlib

Note that some functions (namely init, take, and drop) are shadowed with exception-less versions.

Note that once is not shadowed. Be careful when using once: the resulting sequence is ephemeral and using in a non-ephemeral way raises an exception. As a safer alternative, you can use Seq_e.of_seq_once which gives you a result-based (exception-less) ephemeral sequence.

include module type of Stdlib.Seq with type 'a t = 'a Stdlib.Seq.t and type 'a node = 'a Stdlib.Seq.node
type !'a0 t = 'a Stdlib.Seq.t
and !'a1 node = 'a Stdlib.Seq.node =
  1. | Nil
  2. | Cons of 'a0 * 'a0 t
val is_empty : 'a t -> bool
val uncons : 'a t -> ('a * 'a t) option
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 iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a
val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int
val empty : 'a t
val return : 'a -> 'a t
val cons : 'a -> 'a t -> 'a t
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
val repeat : 'a -> 'a t
val forever : (unit -> 'a) -> 'a t
val cycle : 'a t -> 'a t
val iterate : ('a -> 'a) -> 'a -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
val take_while : ('a -> bool) -> 'a t -> 'a t
val drop_while : ('a -> bool) -> 'a t -> 'a t
val group : ('a -> 'a -> bool) -> 'a t -> 'a t t
val memoize : 'a t -> 'a t
exception Forced_twice
val once : 'a t -> 'a t
val transpose : 'a t t -> 'a t t
val append : 'a t -> 'a t -> 'a t
val concat : 'a t t -> 'a t
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
val concat_map : ('a -> 'b t) -> 'a t -> 'b t
val zip : 'a t -> 'b t -> ('a * 'b) t
val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val interleave : 'a t -> 'a t -> 'a t
val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a t
val product : 'a t -> 'b t -> ('a * 'b) t
val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val unzip : ('a * 'b) t -> 'a t * 'b t
val split : ('a * 'b) t -> 'a t * 'b t
val partition_map : ('a -> ('b, 'c) Stdlib.Either.t) -> 'a t -> 'b t * 'c t
val partition : ('a -> bool) -> 'a t -> 'a t * 'a t
val of_dispenser : (unit -> 'a option) -> 'a t
val to_dispenser : 'a t -> unit -> 'a option
val ints : int -> int t

Lwtreslib-specific safety-shadowing

val init : when_negative_length:'err -> int -> (int -> 'a) -> ('a t, 'err) Stdlib.result
val take : when_negative_length:'err -> int -> 'a t -> ('a t, 'err) Stdlib.result
val drop : when_negative_length:'err -> int -> 'a t -> ('a t, 'err) Stdlib.result
module E : Seqes.Sigs.SEQMON2TRAVERSORS with type ('a, 'e) mon := ('a, 'e) Stdlib.result with type ('a, 'e) callermon := ('a, 'e) Stdlib.result with type ('a, 'e) t := 'a Stdlib.Seq.t
module S : Seqes.Sigs.SEQMON1TRAVERSORS with type 'a mon := 'a Lwt.t with type 'a callermon := 'a Lwt.t with type 'a t := 'a Stdlib.Seq.t
module ES : Seqes.Sigs.SEQMON2TRAVERSORS with type ('a, 'e) mon := ('a, 'e) Stdlib.result Lwt.t with type ('a, 'e) callermon := ('a, 'e) Stdlib.result Lwt.t with type ('a, 'e) t := 'a Stdlib.Seq.t

Lwtreslib-specific extensions

val iter_p : ('a -> unit Lwt.t) -> 'a t -> unit Lwt.t

Similar to iter but wraps the iteration in Lwt. All the steps of the iteration are started concurrently. The promise iter_p f s is resolved only once all the promises of the iteration are. At this point it is either fulfilled if all promises are, or rejected if at least one of them is.

val iteri_p : (int -> 'a -> unit Lwt.t) -> 'a t -> unit Lwt.t

Similar to iteri but wraps the iteration in Lwt. All the steps of the iteration are started concurrently. The promise iter_p f s is resolved only once all the promises of the iteration are. At this point it is either fulfilled if all promises are, or rejected if at least one of them is.

val iter2_p : ('a -> 'b -> unit Lwt.t) -> 'a t -> 'b t -> unit Lwt.t

Similar to iter2 but wraps the iteration in Lwt. All the steps of the iteration are started concurrently. The promise iter2_p f s1 s2 resolves once all the promises of the traversal resolve. At this point it is either:

  • rejected if at least one of the promises is,
  • fulfilled with () if all of the promises are.

Note that similarly to Stdlib.Seq.iter2 this function iterates on the common-length prefix of the two sequences. As a result, the iteration can be successful even if the two sequences are of different lengths.

val iter_ep : ('a -> (unit, 'error Trace.trace) Stdlib.result Lwt.t) -> 'a t -> (unit, 'error Trace.trace) Stdlib.result Lwt.t

Similar to iter but wraps the iteration in result Lwt.t. All the steps of the iteration are started concurrently. The promise iter_ep resolves once all the promises of the traversal resolve. At this point it either:

  • is rejected if at least one of the promises is, otherwise
  • is fulfilled with Error _ if at least one of the promises is, otherwise
  • is fulfilled with Ok () if all the promises are.
val iteri_ep : (int -> 'a -> (unit, 'error Trace.trace) Stdlib.result Lwt.t) -> 'a t -> (unit, 'error Trace.trace) Stdlib.result Lwt.t

Similar to iteri but wraps the iteration in result Lwt.t. All the steps of the iteration are started concurrently. The promise iteri_ep resolves once all the promises of the traversal resolve. At this point it either:

  • is rejected if at least one of the promises is, otherwise
  • is fulfilled with Error _ if at least one of the promises is, otherwise
  • is fulfilled with Ok () if all the promises are.
val iter2_ep : ('a -> 'b -> (unit, 'error Trace.trace) Stdlib.result Lwt.t) -> 'a t -> 'b t -> (unit, 'error Trace.trace) Stdlib.result Lwt.t

Similar to iter2 but wraps the iteration in result Lwt.t. All the steps of the iteration are started concurrently. The promise iter2_ep resolves once all the promises of the traversal resolve. At this point it either:

  • is rejected if at least one of the promises is, otherwise
  • is fulfilled with Error _ if at least one of the promises is, otherwise
  • is fulfilled with Ok () if all the promises are.

Following the behaviour of the Stdlib, the two-sequence traversors stop as soon as one of the two sequences ends: the suffix of the longer sequence is ignored.