Module `Make.Fut`Source

Futures

The futures are registration points for callbacks, storing a state, that are executed in the pool using run.

Sourcetype 'a t

A future value of type 'a

Sourcetype 'a future = 'a t

Constructors

Sourceval return : 'a -> 'a t

Future that is already computed.

Sourceval fail : exn -> 'a t

Future that fails immediately.

Sourceval 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.

Sourceval make1 : ('a -> 'b) -> 'a -> 'b t

Sourceval make2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c t

Basics

Sourceval 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.

Sourceval state : 'a t -> 'a state

State of the future.

Sourceval is_done : 'a t -> bool

Is the future evaluated (success/failure)?

Combinators

Sourceval 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.

Sourceval 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.

Sourceval 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.

Sourceval flat_map : ('a -> 'b t) -> 'a t -> 'b t

Monadic combination of futures.

Sourceval and_then : 'a t -> (unit -> 'b t) -> 'b t

Wait for the first future to succeed, then launch the second.

Sourceval 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.

Sourceval map_a : ('a -> 'b t) -> 'a array -> 'b array t

map_a f a maps f on every element of a, and will return the array of every result if all calls succeed, or an error otherwise.

Sourceval 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.

Sourceval map_l : ('a -> 'b t) -> 'a list -> 'b list t

map_l f l maps f on every element of l, and will return the list of every result if all calls succeed, or an error otherwise.

Sourceval 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.

Sourceval 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.

Sourceval 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 or map_async.

Sourceval map_async : ('a -> 'b) -> 'a t -> 'b t

Map the value inside the future, to be computed in a separated job.

Sourceval monoid_product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t

Cartesian product of the content of these futures.

since 2.8

Sourceval app : ('a -> 'b) t -> 'a t -> 'b t

app f x applies the result of f to the result of x.

Sourceval app_async : ('a -> 'b) t -> 'a t -> 'b t

app_async f x applies the result of f to the result of x, in a separated job scheduled in the pool.

Sourceval 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.

Sourcemodule Infix : sig ... end

include module type of Infix

Sourceval (>>=) : 'a t -> ('a -> 'b t) -> 'b t

Sourceval (>>) : 'a t -> (unit -> 'b t) -> 'b t

Sourceval (>|=) : 'a t -> ('a -> 'b) -> 'b t

Sourceval (<*>) : ('a -> 'b) t -> 'a t -> 'b t

Let operators on OCaml >= 4.08.0, nothing otherwise

since 2.8

include CCShims_syntax.LET with type 'a t := 'a t

Sourceval (let+) : 'a t -> ('a -> 'b) -> 'b t

Sourceval (and+) : 'a t -> 'b t -> ('a * 'b) t

Sourceval (let*) : 'a t -> ('a -> 'b t) -> 'b t

Sourceval (and*) : 'a t -> 'b t -> ('a * 'b) t

package containers-thread

Module Make.FutSource

Futures

Constructors

Basics

Combinators

Module `Make.Fut`Source