module Lwt_stream : sig..end
type 'a t
Type of a stream holding values of type 'a
Naming convention: in this module all function taking a function which is applied to all element of the streams are suffixed by:
- _s when the function returns a thread and calls are serialised
- _p when the function returns a thread and calls are parallelised
from f creates an stream from the given input function. f is called each time more input is needed, and the stream ends when f returns None.
val from_direct : (unit -> 'a option) -> 'a t
from_direct f does the same as Lwt_stream.from but with a function that does not return a thread. It is better than wrapping f into a function which return a thread.
Exception raised by the push function of a push-stream when pushing an element after the end of stream (= None) have been pushed.
val create : unit -> 'a t * ('a option -> unit)
create () returns a new stream and a push function.
val create_with_reference :
unit -> 'a t * ('a option -> unit) * ('b -> unit)
create_with_reference () returns a new stream and a push function. The last function allows to set a reference to an external source. This prevent the external source from being garbage collected.
For example, to convert a reactive event to a stream:
let stream, push, set_ref = Lwt_stream.create_with_reference () in set_ref (map_event push event)
Exception raised by the push function of a bounded push-stream when the stream queue is full and a thread is already waiting to push an element.
class type ['a]bounded_push = object..end
Type of sources for bounded push-streams.
val create_bounded : int -> 'a t * 'a bounded_push
create_bounded size returns a new stream and a bounded push source. The stream can hold a maximum of size elements. When this limit is reached, pushing a new element will block until one is consumed.
Note that you cannot clone or parse (with Lwt_stream.parse) a bounded stream. These functions will raise Invalid_argument if you try to do so.
It raises Invalid_argument if size < 0.
val of_list : 'a list -> 'a t
of_list l creates a stream returning all elements of l
val of_array : 'a array -> 'a t
of_array a creates a stream returning all elements of a
val of_string : string -> char t
of_string str creates a stream returning all characters of str
clone st clone the given stream. Operations on each stream will not affect the other.
# let st1 = Lwt_stream.of_list [1; 2; 3];; val st1 : int Lwt_stream.t = <abstr> # let st2 = Lwt_stream.clone st1;; val st2 : int Lwt_stream.t = <abstr> # lwt x = Lwt_stream.next st1;; val x : int = 1 # lwt y = Lwt_stream.next st2;; val y : int = 1
It raises Invalid_argument if st is a bounded push-stream.
Returns the list of elements of the given stream
Returns the word composed of all characters of the given stream
Data retreival ¶
Exception raised when trying to retreive data from an empty stream.
peek st returns the first element of the stream, if any, without removing it.
npeek n st returns at most the first n elements of st, without removing them.
get st remove and returns the first element of the stream, if any.
nget n st remove and returns at most the first n elements of st.
get_while f st returns the longest prefix of st where all elements satisfy f.
next st remove and returns the next element of the stream, of fail with Lwt_stream.Empty if the stream is empty.
last_new st returns the last element that can be obtained without sleepping, or wait for one if no one is already available.
If fails with Lwt_stream.Empty if the stream has no more elements
junk st remove the first element of st.
njunk n st removes at most the first n elements of the stream.
junk_while f st removes all elements at the beginning of the streams which satisfy f.
junk_old st removes all elements that are ready to be read without yeilding from st.
For example the read_password function of Lwt_read_line use that to junk key previously typed by the user.
val get_available : 'a t -> 'a list
get_available st returns all available elements of l without blocking
val get_available_up_to : int -> 'a t -> 'a list
get_available_up_to n st returns up to n elements of l without blocking
is_empty st returns wether the given stream is empty
val on_terminate : 'a t -> (unit -> unit) -> unit
on_terminate st f executes f when the end of the stream st is reached. Note that the stream may still contains elements if Lwt_stream.peek or similar was used.
Stream transversal ¶
Note: all the following functions are destructive.
# let st1 = Lwt_stream.of_list [1; 2; 3];; val st1 : int Lwt_stream.t = <abstr> # let st2 = Lwt_stream.map string_of_int st1;; val st2 : string Lwt_stream.t = <abstr> # lwt x = Lwt_stream.next st1;; val x : int = 1 # lwt y = Lwt_stream.next st2;; val y : string = "2"
choose l creates an stream from a list of streams. The resulting stream will returns elements returned by any stream of l in an unspecified order.
map f st maps the value returned by st with f
filter f st keeps only value x such that f x is true
filter_map f st filter and map st at the same time
map_list f st applies f on each element of st and flattens the lists returned
fold f s x fold_like function for streams.
iter f s iterates over all elements of the stream
find f s find an element in a stream.
find f s find and map at the same time.
combine s1 s2 combine two streams. The stream will ends when the first stream ends.
append s1 s2 returns a stream which returns all elements of s1, then all elements of s2
concat st returns the concatenation of all streams of st.
flatten st = map_list (fun l -> l) st
type 'a result = | Value of 'a | Error of exn
A value or an error.
parse st f parses st with f. If f raise an exception, st is restored to its previous state.
It raises Invalid_argument if st is a bounded push-stream.
hexdump byte_stream returns a stream which is the same as the output of hexdump -C.
Basically, here is a simple implementation of hexdump -C:
let () = Lwt_main.run (Lwt_io.write_lines Lwt_io.stdout (Lwt_stream.hexdump (Lwt_io.read_lines Lwt_io.stdin)))