This module extends Base.Result
.
include sig ... end
val bin_t : 'a Bin_prot.Type_class.t ‑> 'b Bin_prot.Type_class.t ‑> ('a, 'b) t Bin_prot.Type_class.t
val bin_read_t : 'a Bin_prot.Read.reader ‑> 'b Bin_prot.Read.reader ‑> ('a, 'b) t Bin_prot.Read.reader
val __bin_read_t__ : 'a Bin_prot.Read.reader ‑> 'b Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> ('a, 'b) t) Bin_prot.Read.reader
val bin_reader_t : 'a Bin_prot.Type_class.reader ‑> 'b Bin_prot.Type_class.reader ‑> ('a, 'b) t Bin_prot.Type_class.reader
val bin_size_t : 'a Bin_prot.Size.sizer ‑> 'b Bin_prot.Size.sizer ‑> ('a, 'b) t Bin_prot.Size.sizer
val bin_write_t : 'a Bin_prot.Write.writer ‑> 'b Bin_prot.Write.writer ‑> ('a, 'b) t Bin_prot.Write.writer
val bin_writer_t : 'a Bin_prot.Type_class.writer ‑> 'b Bin_prot.Type_class.writer ‑> ('a, 'b) t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val compare : ('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> ('b ‑> 'b ‑> Core_kernel__.Import.int) ‑> ('a, 'b) t ‑> ('a, 'b) t ‑> Core_kernel__.Import.int
val hash_fold_t : (Base.Hash.state ‑> 'a ‑> Base.Hash.state) ‑> (Base.Hash.state ‑> 'b ‑> Base.Hash.state) ‑> Base.Hash.state ‑> ('a, 'b) t ‑> Base.Hash.state
val t_of_sexp : (Base.Sexp.t ‑> 'a) ‑> (Base.Sexp.t ‑> 'b) ‑> Base.Sexp.t ‑> ('a, 'b) t
val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> ('b ‑> Base.Sexp.t) ‑> ('a, 'b) t ‑> Base.Sexp.t
include module type of Base.Result with type (a, b) Result.t := (a, b) t
Result
is often used to handle error messages.
'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 : (Base.Sexp.t ‑> 'ok) ‑> (Base.Sexp.t ‑> 'err) ‑> Base.Sexp.t ‑> ('ok, 'err) t
val sexp_of_t : ('ok ‑> Base.Sexp.t) ‑> ('err ‑> Base.Sexp.t) ‑> ('ok, 'err) t ‑> Base.Sexp.t
val hash_fold_t : (Base.Hash.state ‑> 'ok ‑> Base.Hash.state) ‑> (Base.Hash.state ‑> 'err ‑> Base.Hash.state) ‑> Base.Hash.state ‑> ('ok, 'err) t ‑> Base.Hash.state
include Base.Monad.S2 with type (a, err) t := (a, err) t
include Base__.Monad_intf.Syntax2 with type (a, e) t := (a, e) t
module Let_syntax : sig ... end
module Monad_infix : Base__.Monad_intf.Infix2 with type (a, e) t := (a, e) t
val return : 'a ‑> ('a, _) 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 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.
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.
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.
val try_with : (unit ‑> 'a) ‑> ('a, exn) t
module Export = Base.Result.Export
module Stable : sig ... end