Module `Base.Or_error`

Type for tracking errors in an Error.t. This is a specialization of the Result type, where the Error constructor carries an Error.t.

A common idiom is to wrap a function that is not implemented on all platforms, e.g.,

val do_something_linux_specific : (unit -> unit) Or_error.t

type 'a t = ('a, Error.t) Result.t: Serialization and comparison of an Error force the error's lazy message.

val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val hash_fold_t : (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a t -> Hash.state

include Sexpable.S1 with type 'a t := 'a t

type 'a t

val t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t

Applicative 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 Applicative.S with type 'a t := 'a t

include Base__.Applicative_intf.For_let_syntax

type 'a t

val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val both : 'a t -> 'b t -> ('a * 'b) t

include Base__.Applicative_intf.Applicative_infix with type 'a t := 'a t

type 'a t

val (<*>) : ('a -> 'b) t -> 'a t -> 'b t: same as apply

val (<*) : 'a t -> unit t -> 'a t
val (*>) : unit t -> 'a t -> 'a t
val (>>|) : 'a t -> ('a -> 'b) -> 'b t

val apply : ('a -> 'b) t -> 'a t -> 'b t
val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t
val map3 : 'a t -> 'b t -> 'c t -> f:('a -> 'b -> 'c -> 'd) -> 'd t
val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t

module Applicative_infix : Base__.Applicative_intf.Applicative_infix with type 'a t := 'a t

include Invariant.S1 with type 'a t := 'a t

type 'a t

val invariant : 'a Base__.Invariant_intf.inv -> 'a t Base__.Invariant_intf.inv

include Monad.S with type 'a t := 'a t

type 'a t

include Base__.Monad_intf.S_without_syntax with type 'a t := 'a t

type 'a t

include Base__.Monad_intf.Infix with type 'a t := 'a t

type 'a t

val (>>=) : 'a t -> ('a -> 'b t) -> 'b t: t >>= 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.

val (>>|) : 'a t -> ('a -> 'b) -> 'b t: t >>| f is t >>= (fun a -> return (f a)).

module Monad_infix : Base__.Monad_intf.Infix with type 'a t := 'a t

val bind : 'a t -> f:('a -> 'b t) -> 'b t: bind t ~f = t >>= f

val return : 'a -> 'a t: return v returns the (trivial) computation that returns v.

val map : 'a t -> f:('a -> 'b) -> 'b t: map t ~f is t >>| f.

val join : 'a t t -> 'a t: join t is t >>= (fun t' -> t').

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.

val all : 'a t list -> 'a list t
val all_unit : unit t list -> unit t: Like all, but ensures that every monadic value in the list produces a unit value, all of which are discarded rather than being collected into a list.

include Base__.Monad_intf.Syntax with type 'a t := 'a t

type 'a t

module Let_syntax : sig ... end

val is_ok : _ t -> bool
val is_error : _ t -> bool
val try_with : ?⁠backtrace:bool -> (unit -> 'a) -> '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 Result.join (try_with f).

val try_with_join : ?⁠backtrace:bool -> (unit -> 'a t) -> 'a t
val ok : 'ok t -> 'ok option: ok t returns None if t is an Error, and otherwise returns the contents of the Ok constructor.

val ok_exn : 'a t -> 'a: ok_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 -> _ t: of_exn ?backtrace exn is Error (Error.of_exn ?backtrace exn).

val of_exn_result : ?⁠backtrace:[ `Get | `This of string ] -> ('a, exn) Result.t -> 'a t

of_exn_result ?backtrace (Ok a) = Ok a

of_exn_result ?backtrace (Error exn) = of_exn ?backtrace exn

val error : ?⁠strict:unit -> string -> 'a -> ('a -> Sexp.t) -> _ t

error 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 : Sexp.t -> _ t
val error_string : string -> _ t: error_string message is Error (Error.of_string message).

val errorf : ('a, unit, string, _ t) Stdlib.format4 -> 'a: 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.

val tag : 'a t -> tag:string -> 'a t: tag t ~tag is Result.map_error t ~f:(Error.tag ~tag). tag_arg is similar.

val tag_s : 'a t -> tag:Sexp.t -> 'a t
val tag_arg : 'a t -> string -> 'b -> ('b -> Sexp.t) -> 'a t
val unimplemented : string -> _ t: For 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 map : 'a t -> f:('a -> 'b) -> 'b t

val iter : 'a t -> f:('a -> unit) -> unit

val iter_error : _ t -> f:(Error.t -> unit) -> unit

val combine_errors : 'a t list -> 'a list t

combine_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])

val combine_errors_unit : unit t list -> unit t: 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.

val filter_ok_at_least_one : 'a t list -> 'a list t: 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.

val find_ok : 'a t list -> 'a t: find_ok ts returns the first value in ts that is Ok, otherwise it returns the same error as combine_errors ts.

val find_map_ok : 'a list -> f:('a -> 'b t) -> 'b t: find_map_ok l ~f returns the first value in l for which f returns Ok, otherwise it returns the same error as combine_errors (List.map l ~f).