Module Eager_deferred__Eager_deferred1
Eager_deferred
partially implements the Deferred
interface, with a type 'a t
equal to 'a Deferred.t
, but where the operations are "eager", that is built upon a world where bind
, map
, and upon
eagerly apply their closure without preemption in the case the deferred they are working with is already determined.
The goal with that approach is that one can locally write the following to switch to such a world.
open Eager_deferred.Use
We do not intend at first for this to implement the entire Deferred
interface, because some of this will require more experimentation and discussions. We can proceed incrementally to enrich this interface.
test/test_eager_deferred
verifies that this interface is a sub interface of the Deferred
interface. For documentation, refer to Deferred
.
include Eager_deferred__.Eager_deferred_intf.Eager_deferred1 with type 'a t := 'a Async_kernel.Deferred.t
include Async_kernel.Invariant.S1 with type 'a t := 'a t
val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv
include Core_kernel.Monad with type 'a t := 'a t
include Base__.Monad_intf.S_without_syntax with type 'a t := 'a t
module Monad_infix : Base__.Monad_intf.Infix with type 'a t := 'a t
val return : 'a -> 'a t
return v
returns the (trivial) computation that returns v.
module Infix : sig ... end
val any : 'a t list -> 'a t
val any_unit : unit t list -> unit t
val both : 'a t -> 'b t -> ('a * 'b) t
val create : ('a Async_kernel.Ivar.t -> unit) -> 'a t
val don't_wait_for : unit t -> unit
val is_determined : 'a t -> bool
val never : unit -> _ t
val ok : 'a t -> ('a, _) Core_kernel.Result.t t
val peek : 'a t -> 'a option
val unit : unit t
val upon : 'a t -> ('a -> unit) -> unit
val value_exn : 'a t -> 'a
val repeat_until_finished : 'state -> ('state -> [ `Repeat of 'state | `Finished of 'result ] t) -> 'result t
module List : Async_kernel.Monad_sequence.S with type 'a monad := 'a t with type 'a t := 'a list
module Or_error : Eager_deferred__.Eager_deferred_intf.Eager_deferred_or_error with type 'a deferred := 'a t