package octez-libs

  1. Overview
  2. Docs
A package that contains multiple base libraries used by the Octez suite

Install

Dune Dependency

www.tezos.com Readme Edit opam file Versions (5)

Authors

  1. T
    Tezos devteam

Maintainers

  1. C
    contact@tezos.com

Sources

tezos-18.1.tar.gz
sha256=aa2f5bc99cc4ca2217c52a1af2a2cdfd3b383208cb859ca2e79ca0903396ca1d
sha512=d68bb3eb615e3dcccc845fddfc9901c95b3c6dc8e105e39522ce97637b1308a7fa7aa1d271351d5933febd7476b2819e1694f31198f1f0919681f1f9cc97cb3a

doc/octez-libs.lwt-result-stdlib/Tezos_lwt_result_stdlib/Lwtreslib/Bare/Seq_s/index.html

Module Bare.Seq_sSource

type +'a node =
  1. | Nil
  2. | Cons of 'a * 'a t

This is similar to S.t but the suspended node is a promise.

and 'a t = unit -> 'a node Lwt.t
include Seqes.Sigs.SEQMON1ALL with type 'a mon := 'a Lwt.t with type 'a t := 'a t
val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Lwt.t
val compare : ('a -> 'b -> int) -> 'a t -> 'b t -> int Lwt.t
val iter : ('a -> unit) -> 'a t -> unit Lwt.t
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a Lwt.t
val iteri : (int -> 'a -> unit) -> 'a t -> unit Lwt.t
val fold_lefti : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b Lwt.t
val for_all : ('a -> bool) -> 'a t -> bool Lwt.t
val exists : ('a -> bool) -> 'a t -> bool Lwt.t
val find : ('a -> bool) -> 'a t -> 'a option Lwt.t
val find_map : ('a -> 'b option) -> 'a t -> 'b option Lwt.t
val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit Lwt.t
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a Lwt.t
val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Lwt.t
val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool Lwt.t
val init : int -> (int -> 'a) -> 'a t
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
val forever : (unit -> 'a) -> '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 flat_map : ('a -> 'b t) -> 'a t -> 'b t
val concat_map : ('a -> 'b t) -> 'a t -> 'b t
val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
val sorted_merge : ('a -> 'a -> int) -> 'a t -> 'a t -> 'a 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 map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val map_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
val partition_map : ('a -> ('b, 'c) 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 is_empty : 'a t -> bool Lwt.t
val uncons : 'a t -> ('a * 'a t) option Lwt.t
val length : 'a t -> int Lwt.t
val empty : 'a t
val return : 'a -> 'a t
val cons : 'a -> 'a t -> 'a t
val repeat : 'a -> 'a t
val cycle : 'a t -> 'a t
val memoize : 'a t -> 'a t
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 zip : 'a t -> 'b t -> ('a * 'b) t
val interleave : 'a t -> 'a t -> 'a t
val product : 'a t -> 'b t -> ('a * 'b) t
val unzip : ('a * 'b) t -> 'a t * 'b t
val split : ('a * 'b) t -> 'a t * 'b t
val to_dispenser : 'a t -> unit -> 'a option Lwt.t
val ints : int -> int t
module E : Seqes.Sigs.SEQMON2TRAVERSORS with type ('a, 'e) mon := ('a, 'e) Stdlib.result Lwt.t with type ('a, 'e) callermon := ('a, 'e) Stdlib.result with type ('a, 'e) t := 'a t
module S : Seqes.Sigs.SEQMON1TRANSFORMERS with type 'a mon := 'a Lwt.t with type 'a callermon := 'a Lwt.t with type 'a t := 'a 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 t
val return_s : 'a Lwt.t -> 'a t

return_s p is a sequence with the value the promise p resolves to as its single element.

val cons_s : 'a Lwt.t -> 'a t -> 'a t

cons_s p s is the sequence containing the value the promise p resolves to, followed by s.

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

Similar to iter but wraps the iteration in Lwt. The steps of the iteration are started concurrently: one iteration is started as soon as the node becomes resolved. 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 iteri_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 take : when_negative_length:'err -> int -> 'a t -> ('a t, 'err) result
val drop : when_negative_length:'err -> int -> 'a t -> ('a t, 'err) result
val of_seq : 'a Seq.t -> 'a t
val of_seq_s : 'a Lwt.t Seq.t -> 'a t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct