Or-error monad extensions.
This module contains various extensions for Core's Or_error monad, including monadic traversal over successful values and T_monad extensions.
This module re-exports all of the original monad.
include module type of Core_kernel.Or_errortype 'a t = ('a, Core_kernel.Error.t) Core_kernel.Result.tval bin_t : 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.tval bin_read_t : 'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.readerval __bin_read_t__ :
'a Bin_prot.Read.reader ->
(Base.Int.t -> 'a t) Bin_prot.Read.readerval bin_reader_t :
'a Bin_prot.Type_class.reader ->
'a t Bin_prot.Type_class.readerval bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizerval bin_write_t : 'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writerval bin_writer_t :
'a Bin_prot.Type_class.writer ->
'a t Bin_prot.Type_class.writerval bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.tinclude module type of struct include Base.Or_error end with type 'a t := 'a tinclude sig ... endval hash_fold_t :
(Base.Hash.state -> 'a -> Base.Hash.state) ->
Base.Hash.state ->
'a t ->
Base.Hash.stateval t_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a tval sexp_of_t : ('a -> Base.Sexp.t) -> 'a t -> Base.Sexp.tApplicative functions don't have quite the same semantics as Applicative.of_Monad(Or_error) would give -- apply (Error e1) (Error e2) returns the combination of e1 and e2, whereas it would only return e1 if it were defined using bind.
include Base.Applicative.S with type 'a t := 'a tmodule Applicative_infix = Base.Or_error.Applicative_infixinclude Base.Invariant.S1 with type 'a t := 'a tval invariant : ('a -> unit) -> 'a t -> unitinclude Base.Monad.S with type 'a t := 'a tt >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.
module Monad_infix = Base.Or_error.Monad_infixval return : 'a -> 'a treturn v returns the (trivial) computation that returns v.
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 Pervasives.ignore. Some monads still do let ignore = ignore_m for historical reasons.
module Let_syntax = Base.Or_error.Let_syntaxmodule Ok = Base.Or_error.Okval is_ok : _ t -> boolval is_error : _ t -> boolval try_with : ?backtrace:bool -> (unit -> 'a) -> 'a ttry_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 Result.join (try_with f).
val ok : 'ok t -> 'ok optionok t returns None if t is an Error, and otherwise returns the contents of the Ok constructor.
val ok_exn : 'a t -> 'aok_exn t throws an exception if t is an Error, and otherwise returns the contents of the Ok constructor.
val of_exn : ?backtrace:[ `Get | `This of string ] -> exn -> _ tof_exn exn is Error (Error.of_exn exn).
val of_exn_result : ('a, exn) Base.Result.t -> 'a tof_exn_result (Ok a) = Ok a, of_exn_result (Error exn) = of_exn exn
val error : ?strict:unit -> string -> 'a -> ('a -> Base.Sexp.t) -> _ terror is a wrapper around Error.create:
error ?strict message a sexp_of_a
= Error (Error.create ?strict message a sexp_of_a)As with Error.create, sexp_of_a a is lazily computed when the info is converted to a sexp. So, if a is mutated in the time between the call to create and the sexp conversion, those mutations will be reflected in the sexp. Use ~strict:() to force sexp_of_a a to be computed immediately.
val error_s : Base.Sexp.t -> _ tval error_string : string -> _ terror_string message is Error (Error.of_string message).
errorf format arg1 arg2 ... is Error (sprintf format arg1 arg2 ...). Note that it calculates the string eagerly, so when performance matters you may want to use error instead.
tag t ~tag is Result.map_error t ~f:(Error.tag ~tag). tag_arg is similar.
val tag_arg : 'a t -> string -> 'b -> ('b -> Base.Sexp.t) -> 'a tval unimplemented : string -> _ tFor marking a given value as unimplemented. Typically combined with conditional compilation, where on some platforms the function is defined normally, and on some platforms it is defined as unimplemented. The supplied string should be the name of the function that is unimplemented.
val iter : 'a t -> f:('a -> unit) -> unitval iter_error : _ t -> f:(Base.Error.t -> unit) -> unitcombine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts. More precisely:
combine_errors [Ok a1; ...; Ok an] = Ok [a1; ...; an]combine_errors [...; Error e1; ...; Error en; ...]
= Error (Error.of_list [e1; ...; en]) combine_errors_unit ts returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.
filter_ok_at_least_one ts returns all values in ts that are Ok if there is at least one, otherwise it returns the same error as combine_errors ts.
find_ok ts returns the first value in ts that is Ok, otherwise it returns the same error as combine_errors ts.
module Stable = Core_kernel.Or_error.Stablemodule On_ok : Traversable.S1_container with type 'a t := 'a tOn_ok treats an Or_error value as a traversable container, containing one value when it is Ok and none otherwise.
Monad extensions for Or_error.
include T_monad.Extensions with type 'a t := 'a twhen_m predicate ~f returns f () when predicate is true, and return () otherwise.
unless_m predicate ~f returns f () when predicate is false, and return () otherwise.
tee_m val ~f executes f val for its monadic action, then returns val.
Example:
let fail_if_negative x =
T_on_error.when_m (Int.is_negative x)
~f:(fun () -> Or_error.error_string "value is negative!")
in
Or_error.(
42 |> T_on_error.tee_m ~f:fail_if_negative >>| (fun x -> x * x)
) (* Ok (1764) *)