Result (melange.Stdlib.Result)

Results

type t('a, 'e) = result('a, 'e) =

| Ok('a)
| Error('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 raise otherwise.

raises Invalid_argument
if r is Error _.

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

get_error r is e if r is Error e and raise otherwise.

raises Invalid_argument
if r is Ok _.

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.