package links

You can search for identifiers within the package.

in-package search v0.2.0

Package contains no libraries

include module type of struct include Result end

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.

val ok : 'a -> ('a, 'e) result

ok v is Ok v.

val value : ('a, 'e) result -> default:'a -> 'a

value r ~default is v if r is Ok v and default otherwise.

val get_ok : ('a, 'e) result -> 'a

get_ok r is v if r is Ok v and raise otherwise.

raises Invalid_argument
if r is Error _.

val get_error : ('a, 'e) result -> 'e

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

raises Invalid_argument
if r is Ok _.

val join : (('a, 'e) result, 'e) result -> ('a, 'e) result

join rr is r if rr is Ok r and rr if rr is Error _.

val fold : ok:('a -> 'c) -> error:('e -> 'c) -> ('a, 'e) result -> 'c

fold ~ok ~error r is ok v if r is Ok v and error e if r is Error e.

val iter : ('a -> unit) -> ('a, 'e) result -> unit

iter f r is f v if r is Ok v and () otherwise.

val iter_error : ('e -> unit) -> ('a, 'e) result -> unit

iter_error f r is f e if r is Error e and () otherwise.

Predicates and comparisons

val equal : 
  ok:('a -> 'a -> bool) ->
  error:('e -> 'e -> bool) ->
  ('a, 'e) result ->
  ('a, 'e) result ->
  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 _.

val compare : 
  ok:('a -> 'a -> int) ->
  error:('e -> 'e -> int) ->
  ('a, 'e) result ->
  ('a, 'e) result ->
  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

val to_option : ('a, 'e) result -> 'a option

to_option r is r as an option, mapping Ok v to Some v and Error _ to None.

val to_list : ('a, 'e) result -> 'a list

to_list r is [v] if r is Ok v and [] otherwise.

val to_seq : ('a, 'e) result -> 'a Seq.t

to_seq r is r as a sequence. Ok v is the singleton sequence containing v and Error _ is the empty sequence.

type ('a, 'b) result = ('a, 'b) Result.t =

| Ok of 'a
| Error of 'b

val return : 'a -> ('b, 'c) Result.result

val error : 'a -> ('b, 'c) Result.result

val bind : 
  ('a, 'b) Result.result ->
  f:('c -> ('d, 'e) Result.result) ->
  ('d, 'e) Result.result

val map : ('a, 'b) Result.result -> f:('c -> 'd) -> ('e, 'b) Result.result

val ok_exn : ('a, 'b) Result.result -> 'c

val ok_internal : 
  ('a, 'b) Result.result ->
  pp:(Format.formatter -> 'c -> unit) ->
  'd

val of_option : 
  'a option ->
  error:('a option -> ('b, 'c) Result.result) ->
  ('b, 'c) Result.result

val try_with : (unit -> 'a) -> ('b, exn) Result.result

val map_error : f:('a -> 'b) -> ('c, 'd) result -> ('e, 'f) Result.result

val of_bool : bool -> error:'a -> (unit, 'b) Result.result

val unpack_error_exn : ('a, 'b) result -> 'c

val is_ok : ('a, 'b) result -> bool

val is_error : ('a, 'b) result -> bool

module O : sig ... end