Module Or_error = Or_error


type 'a t = ('a, Error.t) Result.t

Serialization and comparison of an Error force the error's lazy message. *

val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_read_t : 'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
val __bin_read_t__ : 'a Bin_prot.Read.reader -> (int -> 'a t) Bin_prot.Read.reader
val bin_size_t : 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
val bin_write_t : 'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
include Applicative.S with type 'a t := 'a t
type 'a t
val return : 'a -> 'a t
val apply : ('a -> 'b) t -> 'a t -> 'b t
val map : 'a t -> f:('a -> 'b) -> '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 both : 'a t -> 'b t -> ('a * 'b) t
module Applicative_infix : sig .. end
include module type of Applicative_infix
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t

same as apply

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

same as apply

val (*>) : unit t -> 'a t -> 'a t
include Invariant.S1 with type 'a t := 'a t
type 'a t
val invariant : 'a Invariant_intf.inv -> 'a t Invariant_intf.inv
include Monad.S with type 'a t := 'a t
type 'a t
include 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 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 : Monad_intf.Infix with type 'a t := 'a t
val bind : 'a t -> ('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 Pervasives.ignore. Some monads still do let ignore = ignore_m for historical reasons.

val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
include Monad_intf.Syntax with type 'a t := 'a t
type 'a t
module Let_syntax : sig .. end
val ignore : _ t -> unit t
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_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 exn is Error (Error.of_exn exn).

val of_exn_result : ('a, exn) Result.t -> 'a t

of_exn_result (Ok a) = Ok a, of_exn_result (Error exn) = of_exn exn

val error : ?strict:unit -> string -> 'a -> ('a -> Sexplib.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 : Sexplib.Sexp.t -> _ t
val error_string : string -> _ t

error_string message is Error (Error.of_string message)

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

tag t string is Result.map_error t ~f:(fun e -> Error.tag e string). tag_arg is similar.

val tag_arg : 'a t -> string -> 'b -> ('b -> Sexplib.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 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 returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

module Stable : sig .. end