CCResult
Uses the new "result" type from OCaml 4.03.
type 'a printer = Format.formatter -> 'a -> unit
val return : 'a -> ('a, 'err) t
Successfully return a value.
val fail : 'err -> ('a, 'err) t
Fail with an error.
val of_exn : exn -> ('a, string) t
of_exn e
uses Printexc
to print the exception as a string.
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.
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) 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) 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 iter : ('a -> unit) -> ('a, _) t -> unit
Apply the function only in case of Ok
.
val iter_err : ('err -> unit) -> (_, 'err) t -> unit
Apply the function in case of Error
.
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 get_or_failwith : ('a, string) t -> 'a
get_or_failwith e
returns x
if e = Ok x
, fails otherwise.
val get_lazy : ('b -> 'a) -> ('a, 'b) t -> 'a
get_lazy default_fn x
unwraps x
, but if x = Error e
it returns default_fr e
instead.
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 is_ok : ('a, 'err) t -> bool
Return true if Ok
.
val is_error : ('a, 'err) t -> bool
Return true if Error
.
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.
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
include module type of Infix
Monadic composition. e >>= f
proceeds as f x
if e
is Ok x
or returns e
if e
is an Error
.
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.
Let operators on OCaml >= 4.08.0, nothing otherwise
include CCShimsMkLet_.S2 with type ('a, 'e) t_let2 := ('a, 'e) result
Let operators on OCaml >= 4.08.0, nothing otherwise
include CCShimsMkLet_.S2 with type ('a, 'e) t_let2 := ('a, 'e) result
Same as map_l id
: returns Ok [x1;…;xn]
if l=[Ok x1; …; Ok xn]
, or the first error otherwise.
map_l f [a1; …; an]
applies the function f
to a1, …, an
,and, in case of success for every element, returns the list of Ok
-value. Otherwise, it fails and returns the first error encountered. Tail-recursive.
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.
module type MONAD = sig ... end
val to_opt : ('a, _) t -> 'a option
Convert a result to an option.
val of_opt : 'a option -> ('a, string) t
Convert an option to a result.