# Module `Eager_deferred`

`include Eager_deferred__.Eager_deferred1`

`include sig ... end 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.

`val ignore_m : 'a t -> unit t`

`ignore_m t`

is`map t ~f:(fun _ -> ())`

.`ignore_m`

used to be called`ignore`

, but we decided that was a bad name, because it shadowed the widely used`Caml.ignore`

. Some monads still do`let ignore = ignore_m`

for historical reasons.

`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 ignore : _ t -> unit t`

`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 : module type of Eager_deferred__.Eager_deferred_or_error`

`module Use : sig ... end`

Intended usage is to

`open Eager_deferred.Use`

to shadow operations from the non-eager world and rebind them to their eager counterparts.