Module Async_kernel__.Async_stream
module Deferred = Async_kernel__.Deferred1
type 'a t
= 'a Async_kernel.Tail.Stream.t
sexp_of_t t f
returns a sexp of all of the elements currently available in the stream. It is just for display purposes. There is not_of_sexp
.
val sexp_of_t : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a t -> Ppx_sexp_conv_lib.Sexp.t
val create : ('a Async_kernel.Tail.t -> unit) -> 'a t
create f
returns a streamt
and callsf tail
, where the elements of the stream are determined as the tail is extended, and the end of the stream is reached when the tail is closed.
type 'a next
=
|
Nil
|
Cons of 'a * 'a t
next t
returns a deferred that will become determined when the next part of the stream is determined. This isCons (v, t')
, where v is the next element of the stream and t' is the rest of the stream, or with Nil at the end of the stream.
val next : 'a t -> 'a next Deferred.t
val first_exn : 'a t -> 'a Deferred.t
first_exn t
returns a deferred that becomes determined with the first element oft
.
val of_list : 'a list -> 'a t
of_list l
returns a stream with the elements of list l.
val to_list : 'a t -> 'a list Deferred.t
to_list t
returns a deferred that will become determined with the list of elements in t, if the end of t is reached.
val of_fun : (unit -> 'a Deferred.t) -> 'a t
of_fun f
returns a stream whose elements are determined by callingf
forever.
val copy_to_tail : 'a t -> 'a Async_kernel.Tail.t -> unit Deferred.t
copy_to_tail t tail
reads elements fromt
and puts them intail
, until the end oft
is reached.
val append : 'a t -> 'a t -> 'a t
append t1 t2
returns a stream with all the values of t1, in order, and if t1 ends, these values are followed by all the values of t2.
val concat : 'a t t -> 'a t
concat t
takes a stream of streams and produces a stream that is the concatenation of each stream in order (you see all of stream 1, then all of stream 2... etc.)
val available_now : 'a t -> 'a list * 'a t
available_now t
returns t prefix of t that is available now, along with the rest of the stream.
val filter_deprecated : 'a t -> f:('a -> bool) -> 'a t
filter_deprecated s ~f
returns a stream with one element, v, for each v in s such with f v = true.Using
filter_deprecated
can easily lead to space leaks. It is better to useAsync.Pipe
thanAsync.Stream
.
val filter_map_deprecated : 'a t -> f:('a -> 'b option) -> 'b t
filter_map_deprecated s ~f
returns a stream with one element, v', for each v in s such with f v = Some v'.Using
filter_map_deprecated
can easily lead to space leaks. It is better to useAsync.Pipe
thanAsync.Stream
.
val fold' : 'a t -> init:'b -> f:('b -> 'a -> 'b Deferred.t) -> 'b Deferred.t
fold' t ~init ~f
is like list fold, walking over the elements of the stream in order, as they become available.fold'
returns a deferred that will yield the final value of the accumulator, if the end of the stream is reached.
val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b Deferred.t
fold t ~init ~f
is a variant offold'
in whichf
does not return a deferred.
val iter' : 'a t -> f:('a -> unit Deferred.t) -> unit Deferred.t
iter' t ~f
appliesf
to each element of the stream in turn, as they become available. It continues onto the next element only after the deferred returned byf
becomes determined.
val closed : _ t -> unit Deferred.t
closed t
returns a deferred that becomes determined when the end oft
is reached.
val iter : 'a t -> f:('a -> unit) -> unit
iter t ~f
=don't_wait_for (iter' t ~f:(fun a -> f a; return ()))
val take_until : 'a t -> unit Deferred.t -> 'a t
take_until t d
returns a streamt'
that has the same elements ast
up untild
becomes determined.
val iter_durably' : 'a t -> f:('a -> unit Deferred.t) -> unit Deferred.t
iter_durably' t ~f
is likeiter' t ~f
, except iff
raises an exception it continues with the next element of the stream *and* reraises the exception (to the monitor in scope when iter_durably was called).iter_durably t ~f
is likeiter t ~f
, except iff
raises an exception it continues with the next element of the stream *and* reraises the exception (to the monitor in scope when iter_durably was called).iter_durably_report_end t ~f
is equivalent toiter_durably' t ~f:(fun x -> return (f x))
but it is more efficient
val iter_durably : 'a t -> f:('a -> unit) -> unit
val iter_durably_report_end : 'a t -> f:('a -> unit) -> unit Deferred.t
val length : 'a t -> int Deferred.t
length s
returns a deferred that is determined when the end of s is reached, taking the value of the number of elements in s
val map' : 'a t -> f:('a -> 'b Deferred.t) -> 'b t
map' t f
creates a new stream that with one element, (f v), for each element v of t.
val map : 'a t -> f:('a -> 'b) -> 'b t
map t ~f
creates a new stream that with one element, (f v), for each element v of t.map t f
=map' t ~f:(fun a -> return (f a))
.
val first_n : 'a t -> int -> 'a t
first_n t n
returns a stream with the first n elements of t, if t has n or more elements, or it returns t.
val unfold : 'b -> f:('b -> ('a * 'b) option Deferred.t) -> 'a t
unfold b f
returns a streama1; a2; ...; an
whose elements are determined by the equations:b0 = b Some (a1, b1) = f b0 Some (a2, b2) = f b1 ... None = f bn
val split : ?stop:unit Deferred.t -> ?f:('a -> [ `Continue | `Found of 'b ]) -> 'a t -> 'a t * [ `End_of_stream | `Stopped of 'a t | `Found of 'b * 'a t ] Deferred.t
split ~stop ~f t
returns a pair(p, d)
, wherep
is a prefix oft
that ends for one of three reasons:1. [t] ends 2. stop becomes determined 3. f returns `Found
The deferred
d
describes why the prefix ended, and returns the suffix of the stream in case (2) or (3).
val find : 'a t -> f:('a -> bool) -> [ `End_of_stream | `Found of 'a * 'a t ] Deferred.t
find ~f t
returns a deferred that becomes determined whenf x
is true for some element oft
, or if the end of the stream is reached