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.
fail_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) tOne 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