Base.Result
Result
is often used to handle error messages.
'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.
include Sexpable.S2 with type ('ok, 'err) t := ( 'ok, 'err ) t
val t_of_sexp :
( Sexplib0__.Sexp.t -> 'a ) ->
( Sexplib0__.Sexp.t -> 'b ) ->
Sexplib0__.Sexp.t ->
( 'a, 'b ) t
val sexp_of_t :
( 'a -> Sexplib0__.Sexp.t ) ->
( 'b -> Sexplib0__.Sexp.t ) ->
( 'a, 'b ) t ->
Sexplib0__.Sexp.t
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, _ ) t
val invariant : ( 'a -> unit ) -> ( 'b -> unit ) -> ( 'a, 'b ) t -> unit
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 to_either : ( 'ok, 'err ) t -> ( 'ok, 'err ) Base__Either0.t
to_either
is useful with List.partition_map
. For example:
let ints, exns =
List.partition_map ["1"; "two"; "three"; "4"] ~f:(fun string ->
Result.to_either (Result.try_with (fun () -> Int.of_string string)))
val of_either : ( 'ok, 'err ) Base__Either0.t -> ( 'ok, 'err ) t
val ok_fst : ( 'ok, 'err ) t -> ( 'ok, 'err ) Base__Either0.t
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