Module Result

module Result: sig .. end

Result values.

Result values handle computation results and errors in an explicit and declarative manner without resorting to exceptions.

Since 4.08

Results

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

Raises Invalid_argument otherwise.

let get_error: result('a, 'e) => 'e;

get_error r is e if r is Error e and

Raises 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.

Predicates and comparisons

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.

Converting

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.