'ok
is the return type, and 'err
is often an error message string.
type nat = Zero | Succ of nat
let pred = function
| Succ n -> Ok n
| Zero -> Error "Zero does not have a predecessor"
The return type of pred
could be nat option
, but (nat, string)
Result.t
gives more control over the error message.
val equal : ('ok -> 'ok -> bool) -> ('err -> 'err -> bool) -> ('ok, 'err) t -> ('ok, 'err) t -> bool
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
module Let_syntax : sig ... end
module Monad_infix : sig ... end
val return : 'a -> ('a, 'err) t
val fail : 'err -> (_, 'err) t
val failf : ('a, unit, string, (_, string) t) Stdlib.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
val ok_unit : (unit, _) t
ok_unit = Ok ()
, used to avoid allocation as a performance hack.
module Export : sig ... end