The variant is polymorphic in the error type
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
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 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. This is useful for code that does not want to depend on the exact definition of ('a, 'b) t used, for instance once OCaml gets a standard Result.t type.
val fold : success:('a -> 'b) -> failure:('err -> 'b) -> ('a, 'err) t -> 'bfold ~success ~failure e opens e and, if e = `Ok x, returns success x, otherwise e = `Error s and it returns failure s.
The functions guard, wrap1, wrap2 and wrap3 now return exceptions in case of failure,
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 : (unit -> 'a) -> ('a, string) tSame as guard but uses of_exn to print the exception. See register_printer
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) tPrinter that is generic on the error type
One can register exception printers here, so they will be used by guard, wrap1, etc. The printers should succeed (print) on exceptions they can deal with, and re-raise the exception otherwise. For instance if I register a printer for Not_found, it could look like:
CCError.register_printer
(fun buf exn -> match exn with
| Not_found -> Buffer.add_string buf "Not_found"
| _ -> raise exn
);;This way a printer that doesn't know how to deal with an exception will let other printers do it.
val register_printer : exn printer -> unit