Module Containers.Result

module Result: CCResult

type 'a sequence = ('a -> unit) -> unit

type 'a equal = 'a -> 'a -> bool

type 'a ord = 'a -> 'a -> int

type 'a printer = Buffer.t -> 'a -> unit

type 'a formatter = Format.formatter -> 'a -> unit

Basics

type ('good, 'bad) t = ('good, 'bad) Result.result =

`\|`	`Ok of 'good`
`\|`	`Error of 'bad`

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.

val fail_printf : ('a, Buffer.t, unit, ('a, 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, ('a, string) t) Pervasives.format4 ->
       'a

fail_printf format uses format to obtain an error message and then returns Error msg

val map : ('a -> 'b) -> ('a, 'err) t -> ('b, 'err) t

Map on success

val map_err : ('err1 -> 'err2) -> ('a, 'err1) t -> ('a, 'err2) t

Map on the error variant

val map2 : ('a -> 'b) ->
       ('err1 -> 'err2) -> ('a, 'err1) t -> ('b, 'err2) t

Same as CCResult.map, but also with a function that can transform the error message in case of failure

val iter : ('a -> unit) -> ('a, 'b) t -> unit

Apply the function only in case of Ok

exception Get_error

val get_exn : ('a, 'b) t -> 'a

Extract the value x from Ok x, fails otherwise. You should be careful with this function, and favor other combinators whenever possible.
Raises Get_error if the value is an error.

val get_or : ('a, 'b) 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 flat_map : ('a -> ('b, 'err) t) ->
       ('a, 'err) t -> ('b, 'err) t

val (>|=) : ('a, 'err) t -> ('a -> 'b) -> ('b, 'err) t

val (>>=) : ('a, 'err) t ->
       ('a -> ('b, 'err) t) -> ('b, 'err) t

val equal : ?err:'err equal ->
       'a equal -> ('a, 'err) t equal

val compare : ?err:'err ord ->
       'a ord -> ('a, 'err) t ord

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.

Wrappers

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 : (unit -> 'a) -> ('a, string) t

Same as CCResult.guard but uses CCResult.of_exn to print the exception.

val guard_str_trace : (unit -> 'a) -> ('a, string) t

Same as CCResult.guard_str but uses CCResult.of_exn_trace instead of CCResult.of_exn so that the stack trace is printed.

val wrap1 : ('a -> 'b) -> 'a -> ('b, exn) t

Same as CCResult.guard but gives the function one argument.

val wrap2 : ('a -> 'b -> 'c) -> 'a -> 'b -> ('c, exn) t

Same as CCResult.guard but gives the function two arguments.

val wrap3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> ('d, exn) t

Same as CCResult.guard but gives the function three arguments.

Applicative

val pure : 'a -> ('a, 'err) t

Synonym of CCResult.return

val (<*>) : ('a -> 'b, 'err) t -> ('a, 'err) t -> ('b, 'err) t

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.

val join : (('a, 'err) t, 'err) t -> ('a, 'err) t

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.

val both : ('a, 'err) t -> ('b, 'err) t -> ('a * 'b, 'err) 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.

Infix

module Infix: sig .. end

Collections

val map_l : ('a -> ('b, 'err) t) -> 'a list -> ('b list, 'err) t

val fold_l : ('b -> 'a -> ('b, 'err) t) -> 'b -> 'a list -> ('b, 'err) t

val fold_seq : ('b -> 'a -> ('b, 'err) t) ->
       'b -> 'a sequence -> ('b, 'err) t

Misc

val choose : ('a, 'err) t list -> ('a, 'err list) t

choose l selects a member of l that is a Ok _ value, or returns Error l otherwise, where l is the list of errors.

val retry : int -> (unit -> ('a, 'err) t) -> ('a, 'err list) t

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

Monadic Operations

module Traverse (M : MONAD) : sig .. end

Conversions

val to_opt : ('a, 'b) t -> 'a option

val of_opt : 'a option -> ('a, string) t

val to_seq : ('a, 'b) t -> 'a sequence

type ('a, 'b) error = [ `Error of 'b | `Ok of 'a ]

val of_err : ('a, 'b) error -> ('a, 'b) t

Since 0.17

val to_err : ('a, 'b) t -> ('a, 'b) error

Since 0.17

IO

val pp : 'a printer -> ('a, string) t printer

val pp' : 'a printer ->
       'e printer -> ('a, 'e) t printer

Printer that is generic on the error type
Since 0.19

val print : 'a formatter -> ('a, string) t formatter

val print' : 'a formatter ->
       'e formatter -> ('a, 'e) t formatter

Printer that is generic on the error type
Since 0.19