type 'a future = 'a tval return : 'a -> 'a tFuture that is already computed
val fail : exn -> 'a tFuture that fails immediately
val make : (unit -> 'a) -> 'a tCreate a future, representing a value that will be computed by the function. If the function raises, the future will fail.
val make1 : ('a -> 'b) -> 'a -> 'b tval make2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c tval get : 'a t -> 'aBlocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned.
val is_done : 'a t -> boolIs the future evaluated (success/failure)?
val on_success : 'a t -> ('a -> unit) -> unitAttach a handler to be called upon success
val on_failure : _ t -> (exn -> unit) -> unitAttach a handler to be called upon failure
Attach a handler to be called when the future is evaluated
Wait for the first future to succeed, then launch the second
Future that waits for all previous sequences to terminate. If any future in the list fails, sequence l fails too.
Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails
Maps the value inside the future. The function doesn't run in its own task; if it can take time, use flat_map
val read_chan : in_channel -> Bytes.t tRead the whole channel
val spawn_process : ?stdin:string -> string -> subprocess_res tSpawn a sub-process with the given command (and possibly input); returns a future containing (returncode, stdout, stderr)
val sleep : float -> unit tFuture that returns with success in the given amount of seconds. Blocks the thread! If you need to wait on many events, consider using Timer
module Timer : sig ... endmodule Infix : sig ... end