Uses the new "result" type from OCaml 4.03.
type 'a printer = Buffer.t -> 'a -> unittype 'a formatter = Format.formatter -> 'a -> unitval return : 'a -> ('a, 'err) tSuccessfully return a value
val fail : 'err -> ('a, 'err) tFail with an error
val of_exn_trace : exn -> ('a, string) tof_exn_trace e is similar to of_exn e, but it adds the stacktrace to the error message.
Remember to call Printexc.record_backtrace true and compile with the debug flag for this to work.
val fail_printf : ('a, Buffer.t, unit, ('a, string) t) Pervasives.format4 -> 'afail_printf format uses format to obtain an error message and then returns Error msg
val fail_fprintf :
('a, Format.formatter, unit, ('a, string) t) Pervasives.format4 ->
'afail_printf format uses format to obtain an error message and then returns Error msg
Same as map, but also with a function that can transform the error message in case of failure
val iter : ('a -> unit) -> ('a, _) t -> unitApply the function only in case of Ok
val get_exn : ('a, _) t -> 'aExtract the value x from Ok x, fails otherwise. You should be careful with this function, and favor other combinators whenever possible.
val get_or : ('a, _) t -> default:'a -> 'aget_or e ~default returns x if e = Ok x, default otherwise
val map_or : ('a -> 'b) -> ('a, 'c) t -> default:'b -> 'bmap_or f e ~default returns f x if e = Ok x, default otherwise
val catch : ('a, 'err) t -> ok:('a -> 'b) -> err:('err -> 'b) -> 'bcatch e ~ok ~err calls either ok or err depending on the value of e.
val fold : ok:('a -> 'b) -> error:('err -> 'b) -> ('a, 'err) t -> 'bfold ~ok ~error e opens e and, if e = Ok x, returns ok x, otherwise e = Error s and it returns error s.
val guard : (unit -> 'a) -> ('a, exn) tguard f runs f () and returns its result wrapped in Ok. If f () raises some exception e, then it fails with Error e
val guard_str_trace : (unit -> 'a) -> ('a, string) tSame as guard_str but uses of_exn_trace instead of of_exn so that the stack trace is printed.
val wrap2 : ('a -> 'b -> 'c) -> 'a -> 'b -> ('c, exn) tSame as guard but gives the function two arguments.
val wrap3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> ('d, exn) tSame as guard but gives the function three arguments.
a <*> b evaluates a and b, and, in case of success, returns Ok (a b). Otherwise, it fails, and the error of a is chosen over the error of b if both fail.
join t, in case of success, returns Ok o from Ok (Ok o). Otherwise, it fails with Error e where e is the unwrapped error of t.
both a b, in case of success, returns Ok (o, o') with the ok values of a and b. Otherwise, it fails, and the error of a is chosen over the error of b if both fail.
module Infix : sig ... endchoose l selects a member of l that is a Ok _ value, or returns Error l otherwise, where l is the list of errors.
retry n f calls f at most n times, returning the first result of f () that doesn't fail. If f fails n times, retry n f fails with the list of successive errors.
module type MONAD = sig ... endval to_opt : ('a, _) t -> 'a optionval of_opt : 'a option -> ('a, string) t