Result (base.Base.Result)

type ('ok, 'err) t = ('ok, 'err) Pervasives.result =

| Ok of 'ok

| Error of 'err

'ok is a function's expected return type, and 'err is often an error message string.

      let ric_of_ticker = function
        | "IBM" -> Ok "IBM.N"
        | "MSFT" -> Ok "MSFT.OQ"
        | "AA" -> Ok "AA.N"
        | "CSCO" -> Ok "CSCO.OQ"
        | _ as ticker -> Error (sprintf "can't find ric of %s" ticker)

The return type of ric_of_ticker could be string option, but (string, string) Result.t gives more control over the error message.

include sig ... end

val t_of_sexp : (Sexp.t ‑> 'ok) ‑> (Sexp.t ‑> 'err) ‑> Sexp.t ‑> ('ok, 'err) t

val sexp_of_t : ('ok ‑> Sexp.t) ‑> ('err ‑> Sexp.t) ‑> ('ok, 'err) t ‑> Sexp.t

val compare : ('ok ‑> 'ok ‑> int) ‑> ('err ‑> 'err ‑> int) ‑> ('ok, 'err) t ‑> ('ok, 'err) t ‑> int

val hash_fold_t : (Hash.state ‑> 'ok ‑> Hash.state) ‑> (Hash.state ‑> 'err ‑> Hash.state) ‑> Hash.state ‑> ('ok, 'err) t ‑> Hash.state

include Monad.S2 with type (a, err) t := (a, err) t

type ('a, 'e) t

include Base__.Monad_intf.Infix2 with type (a, e) t := (a, e) t

type ('a, 'e) t

val (>>=) : ('a, 'e) t ‑> ('a ‑> ('b, 'e) t) ‑> ('b, 'e) t

val (>>|) : ('a, 'e) t ‑> ('a ‑> 'b) ‑> ('b, 'e) t

include Base__.Monad_intf.Syntax2 with type (a, e) t := (a, e) t

type ('a, 'e) t

module Let_syntax : sig ... end

module Monad_infix : Base__.Monad_intf.Infix2 with type (a, e) t := (a, e) t

val bind : ('a, 'e) t ‑> f:('a ‑> ('b, 'e) t) ‑> ('b, 'e) t

val return : 'a ‑> ('a, _) t

val map : ('a, 'e) t ‑> f:('a ‑> 'b) ‑> ('b, 'e) t

val join : (('a, 'e) t, 'e) t ‑> ('a, 'e) t

val ignore_m : (_, 'e) t ‑> (unit, 'e) t

val all : ('a, 'e) t list ‑> ('a list, 'e) t

val all_ignore : (unit, 'e) t list ‑> (unit, 'e) t

val ignore : (_, 'err) t ‑> (unit, 'err) t

val fail : 'err ‑> (_, 'err) t

val failf : ('a, unit, string, (_, string) t) Pervasives.format4 ‑> 'a

e.g. failf "Couldn't find bloogle %s" (Bloogle.to_string b)

val is_ok : (_, _) t ‑> bool

val is_error : (_, _) t ‑> bool

val ok : ('ok, _) t ‑> 'ok option

val ok_exn : ('ok, exn) t ‑> 'ok

val ok_or_failwith : ('ok, string) t ‑> 'ok

val error : (_, 'err) t ‑> 'err option

val of_option : 'ok option ‑> error:'err ‑> ('ok, 'err) t

val iter : ('ok, _) t ‑> f:('ok ‑> unit) ‑> unit

val iter_error : (_, 'err) t ‑> f:('err ‑> unit) ‑> unit

val map : ('ok, 'err) t ‑> f:('ok ‑> 'c) ‑> ('c, 'err) t

val map_error : ('ok, 'err) t ‑> f:('err ‑> 'c) ‑> ('ok, 'c) t

val combine : ('ok1, 'err) t ‑> ('ok2, 'err) t ‑> ok:('ok1 ‑> 'ok2 ‑> 'ok3) ‑> err:('err ‑> 'err ‑> 'err) ‑> ('ok3, 'err) t

Returns Ok if both are Ok and Error otherwise.

val combine_errors : ('ok, 'err) t list ‑> ('ok list, 'err list) t

combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts.

This is similar to all from Monad.S2, with the difference that all only returns the first error.

val combine_errors_unit : (unit, 'err) t list ‑> (unit, 'err list) t

combine_errors_unit returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

val ok_fst : ('ok, 'err) t ‑> [ `Fst of 'ok | `Snd of 'err ]

ok_fst is useful with List.partition_map. Continuing the above example:

      let rics, errors = List.partition_map ~f:Result.ok_fst
                           (List.map ~f:ric_of_ticker ["AA"; "F"; "CSCO"; "AAPL"])

val ok_if_true : bool ‑> error:'err ‑> (unit, 'err) t

ok_if_true returns Ok () if bool is true, and Error error if it is false