The deferred analog of Core.Or_error
. It is exposed in std.ml as
Deferred.Or_error
.
The mental model for a function returning an 'a Deferred.Or_error.t
is that the
function never raises. All error cases are caught and expressed as an Error _
result. This module preserves that property.
Unfortunately, there is no way to enforce this property using the type system, so it
is more like a convention, or idiom. A function whose type ends with ... -> 'a
Deferred.Or_error.t
and still raises should be considered broken, and be fixed. With
that property in mind, Deferred.Or_error.List.iter
, for example, does not wrap the
execution of the given iter function f
inside a monitor. If one of these
application raises, the whole function Deferred.Or_error.List.iter
will raise as a
way to try to alert the developer that one the function is broken and needs attention
and fixing, rather than silently catching the error and converting it to
Or_error.Error
.
This behavior is consistent with Core.Or_error
's treatment of user-supplied
functions.
If you have to deal with a function that does not respect this idiom, you can use
Deferred.Or_error.try_with_join
to wrap its execution and enforce this property.
module Deferred = Async_kernel__.Deferred1
The applicative operations match the behavior of the applicative operations in
Or_error
. This means that all
and all_ignore
are equivalent to combine_errors
and combine_errors_unit
respectively.
include Core_kernel.Applicative.S with type a t := a t
val return : 'a ‑> 'a t
module Applicative_infix : sig ... end
return x = Deferred.return (Ok x)
*
include Core_kernel.Monad.S with type a t := a t
include Base__.Monad_intf.S_without_syntax with type a t := a t
type 'a t
A monad is an abstraction of the concept of sequencing of computations. A value of type 'a monad represents a computation that returns a value of type 'a.
include Base__.Monad_intf.Infix with type a t := a t
module Monad_infix : Base__.Monad_intf.Infix with type a t := a t
val ok_exn : 'a t ‑> 'a Deferred.t
These functions are direct analogs of the corresponding Core.Or_error
functions.
val of_exn : exn ‑> _ t
val of_exn_result : ('a, exn) Core_kernel.Result.t Deferred.t ‑> 'a t
val error : string ‑> 'a ‑> ('a ‑> Core_kernel.Sexp.t) ‑> _ t
val error_s : Core_kernel.Sexp.t ‑> _ t
val error_string : string ‑> _ t
val errorf : ('a, unit, string, _ t) Core_kernel.format4 ‑> 'a
val tag_arg : 'a t ‑> string ‑> 'b ‑> ('b ‑> Core_kernel.Sexp.t) ‑> 'a t
val unimplemented : string ‑> _ t
val try_with : ?extract_exn:bool ‑> ?here:Lexing.position ‑> ?name:string ‑> (unit ‑> 'a Deferred.t) ‑> 'a t
try_with f
catches exceptions thrown by f
and returns them in the Result.t as an
Error.t. try_with_join
is like try_with
, except that f
can throw exceptions or
return an Error
directly, without ending up with a nested error; it is equivalent to
try_with f >>| Result.join
.
The option extract_exn
is passed along to Monitor.try_with ?extract_exn
and
specifies whether or not the monitor exn wrapper should be skipped (extract_exn:true
or kept (extract_exn:false
).
module List : Async_kernel.Monad_sequence.S with type a monad := a t with type a t := a list
All of the List
functions that take a how
argument treat it the following way: