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 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
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 : sig ... end