Module Make.Fut
Futures
The futures are registration points for callbacks, storing a state
, that are executed in the pool using run
.
type 'a future
= 'a t
Constructors
val return : 'a -> 'a t
Future that is already computed.
val fail : exn -> 'a t
Future that fails immediately.
val make : (unit -> 'a) -> 'a t
Create a future, representing a value that will be computed by the function. If the function raises, the future will fail.
Basics
val get : 'a t -> 'a
Blocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned. Raise e if the future failed with e.
val is_done : 'a t -> bool
Is the future evaluated (success/failure)?
Combinators
val on_success : 'a t -> ('a -> unit) -> unit
Attach a handler to be called upon success. The handler should not call functions on the future. Might be evaluated now if the future is already done.
val on_failure : _ t -> (exn -> unit) -> unit
Attach a handler to be called upon failure. The handler should not call any function on the future. Might be evaluated now if the future is already done.
val on_finish : 'a t -> ('a state -> unit) -> unit
Attach a handler to be called when the future is evaluated. The handler should not call functions on the future. Might be evaluated now if the future is already done.
val and_then : 'a t -> (unit -> 'b t) -> 'b t
Wait for the first future to succeed, then launch the second.
val sequence_a : 'a t array -> 'a array t
Future that waits for all previous futures to terminate. If any future in the array fails,
sequence_a l
fails too.
val map_a : ('a -> 'b t) -> 'a array -> 'b array t
map_a f a
mapsf
on every element ofa
, and will return the array of every result if all calls succeed, or an error otherwise.
val sequence_l : 'a t list -> 'a list t
Future that waits for all previous futures to terminate. If any future in the list fails,
sequence_l l
fails too.
val map_l : ('a -> 'b t) -> 'a list -> 'b list t
map_l f l
mapsf
on every element ofl
, and will return the list of every result if all calls succeed, or an error otherwise.
val choose_a : 'a t array -> 'a t
Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails.
val choose_l : 'a t list -> 'a t
Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails.
val map : ('a -> 'b) -> 'a t -> 'b t
Map the value inside the future. The function doesn't run in its own task; if it can take time, use
flat_map
ormap_async
.
val map_async : ('a -> 'b) -> 'a t -> 'b t
Map the value inside the future, to be computed in a separated job.
val app_async : ('a -> 'b) t -> 'a t -> 'b t
app_async f x
applies the result off
to the result ofx
, in a separated job scheduled in the pool.
val sleep : float -> unit t
Future that returns with success in the given amount of seconds. Blocks the thread! If you need to wait on many events, consider using
CCTimer
.
module Infix : sig ... end