module Result: sig .. end
Result values.
Result values handle computation results and errors in an explicit and declarative manner without resorting to exceptions.
type ('a, 'e) t = ('a, 'e) result =
| |
Ok of 'a |
| |
Error of 'e |
The type for result values. Either a value Ok v
or an error Error e
.
let ok: 'a => result('a, 'e);
ok v
is Ok v
.
let error: 'e => result('a, 'e);
error e
is Error e
.
let value: (result('a, 'e), ~default: 'a) => 'a;
value r ~default
is v
if r
is Ok v
and default
otherwise.
let get_ok: result('a, 'e) => 'a;
get_ok r
is v
if r
is Ok v
and
Invalid_argument
otherwise.let get_error: result('a, 'e) => 'e;
get_error r
is e
if r
is Error e
and
Invalid_argument
otherwise.let bind: (result('a, 'e), 'a => result('b, 'e)) => result('b, 'e);
bind r f
is f v
if r
is Ok v
and r
if r
is Error _
.
let join: result(result('a, 'e), 'e) => result('a, 'e);
join rr
is r
if rr
is Ok r
and rr
if rr
is Error _
.
let map: ('a => 'b, result('a, 'e)) => result('b, 'e);
map f r
is Ok (f v)
if r
is Ok v
and r
if r
is Error _
.
let map_error: ('e => 'f, result('a, 'e)) => result('a, 'f);
map_error f r
is Error (f e)
if r
is Error e
and r
if
r
is Ok _
.
let fold: (~ok: 'a => 'c, ~error: 'e => 'c, result('a, 'e)) => 'c;
fold ~ok ~error r
is ok v
if r
is Ok v
and error e
if r
is Error e
.
let iter: ('a => unit, result('a, 'e)) => unit;
iter f r
is f v
if r
is Ok v
and ()
otherwise.
let iter_error: ('e => unit, result('a, 'e)) => unit;
iter_error f r
is f e
if r
is Error e
and ()
otherwise.
let is_ok: result('a, 'e) => bool;
is_ok r
is true
if and only if r
is Ok _
.
let is_error: result('a, 'e) => bool;
is_error r
is true
if and only if r
is Error _
.
let equal:
(
~ok: ('a, 'a) => bool,
~error: ('e, 'e) => bool,
result('a, 'e),
result('a, 'e)
) =>
bool;
equal ~ok ~error r0 r1
tests equality of r0
and r1
using ok
and error
to respectively compare values wrapped by Ok _
and
Error _
.
let compare:
(
~ok: ('a, 'a) => int,
~error: ('e, 'e) => int,
result('a, 'e),
result('a, 'e)
) =>
int;
compare ~ok ~error r0 r1
totally orders r0
and r1
using ok
and
error
to respectively compare values wrapped by Ok _
and Error _
.
Ok _
values are smaller than Error _
values.
let to_option: result('a, 'e) => option('a);
to_option r
is r
as an option, mapping Ok v
to Some v
and
Error _
to None
.
let to_list: result('a, 'e) => list('a);
to_list r
is [v]
if r
is Ok v
and []
otherwise.
let to_seq: result('a, 'e) => Seq.t('a);
to_seq r
is r
as a sequence. Ok v
is the singleton sequence
containing v
and Error _
is the empty sequence.