Uses the new "result" type from OCaml 4.03.
val of_exn_trace : exn ‑> ('a, string) t
of_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, ('b, string) t) Pervasives.format4 ‑> 'a
fail_printf format
uses format
to obtain an error message
and then returns Error msg
.
val fail_fprintf : ('a, Format.formatter, unit, ('b, string) t) Pervasives.format4 ‑> 'a
fail_fprintf format
uses format
to obtain an error message
and then returns Error msg
.
add_ctx msg
leaves Ok x
untouched, but transforms
Error s
into Error s'
where s'
contains the additional
context given by msg
.
val add_ctxf : ('a, Format.formatter, unit, ('b, string) t ‑> ('b, string) t) Pervasives.format4 ‑> 'a
add_ctxf format_message
is similar to add_ctx but with
Format for printing the message (eagerly).
Example:
add_ctxf "message(number %d, foo: %B)" 42 true (Error "error)"
Like map, but also with a function that can transform the error message in case of failure.
val get_exn : ('a, _) t ‑> 'a
Extract 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 ‑> 'a
get_or e ~default
returns x
if e = Ok x
, default
otherwise.
val map_or : ('a ‑> 'b) ‑> ('a, 'c) t ‑> default:'b ‑> 'b
map_or f e ~default
returns f x
if e = Ok x
, default
otherwise.
val catch : ('a, 'err) t ‑> ok:('a ‑> 'b) ‑> err:('err ‑> 'b) ‑> 'b
catch 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 ‑> 'b
fold ~ok ~error e
opens e
and, if e = Ok x
, returns
ok x
, otherwise e = Error s
and it returns error s
.
val fold_ok : ('a ‑> 'b ‑> 'a) ‑> 'a ‑> ('b, _) t ‑> 'a
fold_ok f acc r
will compute f acc x
if r=Ok x
,
and return acc
otherwise, as if the result were a mere option.
val guard : (unit ‑> 'a) ‑> ('a, exn) t
guard 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) t
Like 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) t
Like guard but gives the function two arguments.
val wrap3 : ('a ‑> 'b ‑> 'c ‑> 'd) ‑> 'a ‑> 'b ‑> 'c ‑> ('d, exn) t
Like 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 ... end
choose 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.