Module `Base.Or_error`Source

Type for tracking errors in an Error.t. This is a specialization of the Result type, where the Error constructor carries an Error.t.

A common idiom is to wrap a function that is not implemented on all platforms, e.g.,

  val do_something_linux_specific : (unit -> unit) Or_error.t

module Sexp := Base__.Sexp0

Source

val compare__bits64 : 
  ('a -> 'a -> int) ->
  ('a, Base.Error.t) Base.Result.t__bits64 ->
  ('a, Base.Error.t) Base.Result.t__bits64 ->
  int @@ portable

Source

val compare__bits64__local : 
  ('a @ local -> 'a @ local -> int) ->
  ('a, Base.Error.t) Base.Result.t__bits64 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits64 @ local ->
  int @@ portable

Source

val compare__bits32 : 
  ('a -> 'a -> int) ->
  ('a, Base.Error.t) Base.Result.t__bits32 ->
  ('a, Base.Error.t) Base.Result.t__bits32 ->
  int @@ portable

Source

val compare__bits32__local : 
  ('a @ local -> 'a @ local -> int) ->
  ('a, Base.Error.t) Base.Result.t__bits32 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits32 @ local ->
  int @@ portable

Source

val compare__word : 
  ('a -> 'a -> int) ->
  ('a, Base.Error.t) Base.Result.t__word ->
  ('a, Base.Error.t) Base.Result.t__word ->
  int @@ portable

Source

val compare__word__local : 
  ('a @ local -> 'a @ local -> int) ->
  ('a, Base.Error.t) Base.Result.t__word @ local ->
  ('a, Base.Error.t) Base.Result.t__word @ local ->
  int @@ portable

Source

val compare__float64 : 
  ('a -> 'a -> int) ->
  ('a, Base.Error.t) Base.Result.t__float64 ->
  ('a, Base.Error.t) Base.Result.t__float64 ->
  int @@ portable

Source

val compare__float64__local : 
  ('a @ local -> 'a @ local -> int) ->
  ('a, Base.Error.t) Base.Result.t__float64 @ local ->
  ('a, Base.Error.t) Base.Result.t__float64 @ local ->
  int @@ portable

Source

val compare__float32 : 
  ('a -> 'a -> int) ->
  ('a, Base.Error.t) Base.Result.t__float32 ->
  ('a, Base.Error.t) Base.Result.t__float32 ->
  int @@ portable

Source

val compare__float32__local : 
  ('a @ local -> 'a @ local -> int) ->
  ('a, Base.Error.t) Base.Result.t__float32 @ local ->
  ('a, Base.Error.t) Base.Result.t__float32 @ local ->
  int @@ portable

Source

val equal__bits64 : 
  ('a -> 'a -> bool) ->
  ('a, Base.Error.t) Base.Result.t__bits64 ->
  ('a, Base.Error.t) Base.Result.t__bits64 ->
  bool @@ portable

Source

val equal__bits64__local : 
  ('a @ local -> 'a @ local -> bool) ->
  ('a, Base.Error.t) Base.Result.t__bits64 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits64 @ local ->
  bool @@ portable

Source

val equal__bits32 : 
  ('a -> 'a -> bool) ->
  ('a, Base.Error.t) Base.Result.t__bits32 ->
  ('a, Base.Error.t) Base.Result.t__bits32 ->
  bool @@ portable

Source

val equal__bits32__local : 
  ('a @ local -> 'a @ local -> bool) ->
  ('a, Base.Error.t) Base.Result.t__bits32 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits32 @ local ->
  bool @@ portable

Source

val equal__word : 
  ('a -> 'a -> bool) ->
  ('a, Base.Error.t) Base.Result.t__word ->
  ('a, Base.Error.t) Base.Result.t__word ->
  bool @@ portable

Source

val equal__word__local : 
  ('a @ local -> 'a @ local -> bool) ->
  ('a, Base.Error.t) Base.Result.t__word @ local ->
  ('a, Base.Error.t) Base.Result.t__word @ local ->
  bool @@ portable

Source

val equal__float64 : 
  ('a -> 'a -> bool) ->
  ('a, Base.Error.t) Base.Result.t__float64 ->
  ('a, Base.Error.t) Base.Result.t__float64 ->
  bool @@ portable

Source

val equal__float64__local : 
  ('a @ local -> 'a @ local -> bool) ->
  ('a, Base.Error.t) Base.Result.t__float64 @ local ->
  ('a, Base.Error.t) Base.Result.t__float64 @ local ->
  bool @@ portable

Source

val equal__float32 : 
  ('a -> 'a -> bool) ->
  ('a, Base.Error.t) Base.Result.t__float32 ->
  ('a, Base.Error.t) Base.Result.t__float32 ->
  bool @@ portable

Source

val equal__float32__local : 
  ('a @ local -> 'a @ local -> bool) ->
  ('a, Base.Error.t) Base.Result.t__float32 @ local ->
  ('a, Base.Error.t) Base.Result.t__float32 @ local ->
  bool @@ portable

Source

val globalize__bits64 : 
  ('a @ local -> 'a) ->
  ('a, Base.Error.t) Base.Result.t__bits64 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits64 @@ portable

Source

val globalize__bits32 : 
  ('a @ local -> 'a) ->
  ('a, Base.Error.t) Base.Result.t__bits32 @ local ->
  ('a, Base.Error.t) Base.Result.t__bits32 @@ portable

Source

val globalize__word : 
  ('a @ local -> 'a) ->
  ('a, Base.Error.t) Base.Result.t__word @ local ->
  ('a, Base.Error.t) Base.Result.t__word @@ portable

Source

val globalize__float64 : 
  ('a @ local -> 'a) ->
  ('a, Base.Error.t) Base.Result.t__float64 @ local ->
  ('a, Base.Error.t) Base.Result.t__float64 @@ portable

Source

val globalize__float32 : 
  ('a @ local -> 'a) ->
  ('a, Base.Error.t) Base.Result.t__float32 @ local ->
  ('a, Base.Error.t) Base.Result.t__float32 @@ portable

Source

val sexp_of_t__bits64 : 
  ('a -> Sexplib0.Sexp.t) ->
  ('a, Base.Error.t) Base.Result.t__bits64 ->
  Sexplib0.Sexp.t @@ portable

Source

val sexp_of_t__bits32 : 
  ('a -> Sexplib0.Sexp.t) ->
  ('a, Base.Error.t) Base.Result.t__bits32 ->
  Sexplib0.Sexp.t @@ portable

Source

val sexp_of_t__word : 
  ('a -> Sexplib0.Sexp.t) ->
  ('a, Base.Error.t) Base.Result.t__word ->
  Sexplib0.Sexp.t @@ portable

Source

val sexp_of_t__float64 : 
  ('a -> Sexplib0.Sexp.t) ->
  ('a, Base.Error.t) Base.Result.t__float64 ->
  Sexplib0.Sexp.t @@ portable

Source

val sexp_of_t__float32 : 
  ('a -> Sexplib0.Sexp.t) ->
  ('a, Base.Error.t) Base.Result.t__float32 ->
  Sexplib0.Sexp.t @@ portable

Source

val t_of_sexp__bits64 : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  ('a, Base.Error.t) Base.Result.t__bits64 @@ portable

Source

val t_of_sexp__bits32 : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  ('a, Base.Error.t) Base.Result.t__bits32 @@ portable

Source

val t_of_sexp__word : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  ('a, Base.Error.t) Base.Result.t__word @@ portable

Source

val t_of_sexp__float64 : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  ('a, Base.Error.t) Base.Result.t__float64 @@ portable

Source

val t_of_sexp__float32 : 
  (Sexplib0.Sexp.t -> 'a) ->
  Sexplib0.Sexp.t ->
  ('a, Base.Error.t) Base.Result.t__float32 @@ portable

Sourcetype ('a : value_or_null) t = ('a, Base.Error.t) Base.Result.t

Serialization and comparison of an Error force the error's lazy message.

Source

val compare : 
  ('a : value_or_null). (('a : value_or_null) -> ('a : value_or_null) -> int) ->
  ('a : value_or_null) Base.Or_error.t ->
  ('a : value_or_null) Base.Or_error.t ->
  int

Source

val compare__local : 
  ('a : value_or_null). (('a : value_or_null) @ local ->
                          ('a : value_or_null) @ local ->
                          int) ->
  ('a : value_or_null) Base.Or_error.t @ local ->
  ('a : value_or_null) Base.Or_error.t @ local ->
  int

Source

val equal : 
  ('a : value_or_null). (('a : value_or_null) -> ('a : value_or_null) -> bool) ->
  ('a : value_or_null) Base.Or_error.t ->
  ('a : value_or_null) Base.Or_error.t ->
  bool

Source

val equal__local : 
  ('a : value_or_null). (('a : value_or_null) @ local ->
                          ('a : value_or_null) @ local ->
                          bool) ->
  ('a : value_or_null) Base.Or_error.t @ local ->
  ('a : value_or_null) Base.Or_error.t @ local ->
  bool

Source

val globalize : 
  ('a : value_or_null). ('a @ local -> 'a) ->
  'a Base.Or_error.t @ local ->
  'a Base.Or_error.t

Source

val hash_fold_t : 
  ('a : value_or_null). (Ppx_hash_lib.Std.Hash.state ->
                          ('a : value_or_null) ->
                          Ppx_hash_lib.Std.Hash.state) ->
  Ppx_hash_lib.Std.Hash.state ->
  ('a : value_or_null) Base.Or_error.t ->
  Ppx_hash_lib.Std.Hash.state

Source

val sexp_of_t : 
  ('a : value_or_null). (('a : value_or_null) -> Sexplib0.Sexp.t) ->
  ('a : value_or_null) Base.Or_error.t ->
  Sexplib0.Sexp.t

Source

val t_of_sexp : 
  ('a : value_or_null). (Sexplib0.Sexp.t -> ('a : value_or_null)) ->
  Sexplib0.Sexp.t ->
  ('a : value_or_null) Base.Or_error.t

Source

val t_sexp_grammar : 
  ('a : value_or_null). ('a : value_or_null) Sexplib0.Sexp_grammar.t ->
  ('a : value_or_null) Base.Or_error.t Sexplib0.Sexp_grammar.t @@ portable

Applicative functions don't have quite the same semantics as Applicative.Of_Monad(Or_error) would give -- apply (Error e1) (Error e2) returns the combination of e1 and e2, whereas it would only return e1 if it were defined using bind.

include Base.Applicative.S__'value_or_null_mod_maybe_null'__local
  with type ('a : value_or_null) t := 'a Base.Or_error.t

Source

val apply : 
  ('a -> 'b) Base.Or_error.t ->
  'a Base.Or_error.t ->
  'b Base.Or_error.t

Applies the functions in one t to the values in another. Well-behaved applicatives satisfy these "laws", using <*> as infix apply:

return Fn.id <*> t is equivalent to t
return Fn.compose <*> tf <*> tg <*> tx is equivalent to tf <*> (tg <*> tx)
return f <*> return x is equivalent to return (f x)
tf <*> return x is equivalent to return (fun f -> f x) <*> tf

Source

val both : 
  'a Base.Or_error.t ->
  'b Base.Or_error.t ->
  ('a * 'b) Base.Or_error.t

Combines values in two ts as tuples. Using <*> as infix apply, equivalent to return (fun a b -> a, b) <*> ta <*> tb.

Source

val map2 : 
  'a Base.Or_error.t ->
  'b Base.Or_error.t ->
  f:('a -> 'b -> 'c) @ local ->
  'c Base.Or_error.t

Combines the contents of two ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb.

Source

val map3 : 
  'a Base.Or_error.t ->
  'b Base.Or_error.t ->
  'c Base.Or_error.t ->
  f:('a -> 'b -> 'c -> 'd) @ local ->
  'd Base.Or_error.t

Combines the contents of three ts. Using <*> as infix apply, equivalent to return f <*> ta <*> tb <*> tc.

Source

val (<*>) : 
  ('a -> 'b) Base.Or_error.t ->
  'a Base.Or_error.t ->
  'b Base.Or_error.t

Sourceval (<*) : 'a Base.Or_error.t -> unit Base.Or_error.t -> 'a Base.Or_error.t

Sourceval (*>) : unit Base.Or_error.t -> 'a Base.Or_error.t -> 'a Base.Or_error.t

module Applicative_infix : sig ... end

include Base.Invariant.S1 with type 'a t := 'a Base.Or_error.t

Sourceval invariant : ('a -> unit) -> 'a Base.Or_error.t -> unit

include Base.Monad.S__'value_or_null_mod_maybe_null'__local
  with type ('a : value_or_null) t := 'a Base.Or_error.t

Sourceval return : 'a -> 'a Base.Or_error.t

Convert a value to a t.

Source

val bind : 
  'a Base.Or_error.t ->
  f:('a -> 'b Base.Or_error.t) @ local ->
  'b Base.Or_error.t

Sequences computations. bind t ~f computes f v for value(s) v in t. Well-behaved monads satisfy these "laws" (where ( >>= ) is the infix bind operator):

map t ~f is equivalent to bind t ~f:(fun x -> return (f x))
return x >>= f is equivalent to f x
t >>= return is equivalent to t
(t >>= f) >>= g is equivalent to t >>= fun x -> f x >>= g

Sourceval join : 'a Base.Or_error.t Base.Or_error.t -> 'a Base.Or_error.t

Combines nested t into just one layer. Equivalent to bind t ~f:Fn.id.

Sourceval ignore_m : 'a Base.Or_error.t -> unit Base.Or_error.t

Ignores contained values of t. Equivalent to map t ~f:ignore.

Sourceval all : 'a Base.Or_error.t list -> 'a list Base.Or_error.t

Combines a list of t.

Sourceval all_unit : unit Base.Or_error.t list -> unit Base.Or_error.t

Combines a list of t whose contents are unimportant.

Source

val (>>=) : 
  'a Base.Or_error.t ->
  ('a -> 'b Base.Or_error.t) @ local ->
  'b Base.Or_error.t

Infix bind.

Sourceval (>>|) : 'a Base.Or_error.t -> ('a -> 'b) @ local -> 'b Base.Or_error.t

Infix map.

module Monad_infix : sig ... end

Sourcemodule Let_syntax : sig ... end

Sourceval is_ok : ('a : value_or_null). 'a Base.Or_error.t -> bool @@ portable

Sourceval is_error : ('a : value_or_null). 'a Base.Or_error.t -> bool @@ portable

Source

val try_with : 
  ('a : value_or_null). ?backtrace:bool ->
  (unit -> 'a) @ local ->
  'a Base.Or_error.t @@ portable

try_with f catches exceptions thrown by f and returns them in the Result.t as an Error.t. try_with_join is like try_with, except that f can throw exceptions or return an Error directly, without ending up with a nested error; it is equivalent to Result.join (try_with f).

Source

val try_with_join : 
  ('a : value_or_null). ?backtrace:bool ->
  (unit -> 'a Base.Or_error.t) @ local ->
  'a Base.Or_error.t @@ portable

Sourceval ok : ('ok : value_or_null). 'ok Base.Or_error.t -> 'ok option @@ portable

ok t returns None if t is an Error, and otherwise returns the contents of the Ok constructor.

Sourceval ok_exn : ('a : value_or_null). 'a Base.Or_error.t -> 'a @@ portable

ok_exn t throws an exception if t is an Error, and otherwise returns the contents of the Ok constructor.

Source

val of_exn : 
  ('a : value_or_null). ?backtrace:[ `Get | `This of string ] ->
  exn ->
  'a Base.Or_error.t @@ portable

of_exn ?backtrace exn is Error (Error.of_exn ?backtrace exn).

Source

val of_exn_result : 
  ('a : value_or_null). ?backtrace:[ `Get | `This of string ] ->
  ('a, exn) Base.Result.t ->
  'a Base.Or_error.t @@ portable

of_exn_result ?backtrace (Ok a) = Ok a

of_exn_result ?backtrace (Error exn) = of_exn ?backtrace exn

Source

val of_option : 
  ('a : value_or_null). 'a option ->
  error:Base.Error.t ->
  'a Base.Or_error.t @@ portable

of_option t returns Ok 'a if t is Some 'a, and otherwise returns the supplied error as Error error

Source

val of_option_lazy : 
  ('a : value_or_null). 'a option ->
  error:Base.Error.t Base.Lazy.t ->
  'a Base.Or_error.t @@ portable

Calls of_option ~error:(Error.of_lazy_t error).

Source

val of_option_lazy_sexp : 
  ('a : value_or_null). 'a option ->
  error:Base.Or_error.Sexp.t Base.Lazy.t ->
  'a Base.Or_error.t @@ portable

Calls of_option ~error:(Error.of_lazy_sexp error).

Source

val of_option_lazy_string : 
  ('a : value_or_null). 'a option ->
  error:string Base.Lazy.t ->
  'a Base.Or_error.t @@ portable

Calls of_option ~error:(Error.of_lazy error).

Source

val error : 
  'a ('b : value_or_null). ?here:Stdlib.Lexing.position ->
  ?strict:unit ->
  string ->
  'a ->
  ('a -> Base.Or_error.Sexp.t) ->
  'b Base.Or_error.t @@ portable

error is a wrapper around Error.create:

  error ?strict message a sexp_of_a = Error (Error.create ?strict message a sexp_of_a)

As with Error.create, sexp_of_a a is lazily computed when the info is converted to a sexp. So, if a is mutated in the time between the call to create and the sexp conversion, those mutations will be reflected in the sexp. Use ~strict:() to force sexp_of_a a to be computed immediately.

Source

val error_s : 
  ('a : value_or_null). Base.Or_error.Sexp.t ->
  'a Base.Or_error.t @ portable @@ portable

Source

val error_string : 
  ('a : value_or_null). string ->
  'a Base.Or_error.t @ portable @@ portable

error_string message is Error (Error.of_string message).

Source

val errorf : 
  'a ('b : value_or_null). ('a, unit, string, 'b Base.Or_error.t)
                             Stdlib.format4 ->
  'a @@ portable

errorf format arg1 arg2 ... is Error (sprintf format arg1 arg2 ...). Note that it calculates the string eagerly, so when performance matters you may want to use error instead.

Source

val errorf_portable : 
  'a ('b : value_or_null). ('a,
                             unit,
                             string,
                             unit ->
                             'b Base.Or_error.t @ portable)
                             Stdlib.format4 ->
  'a @@ portable

errorf_portable format arg1 arg2 ... () is like errorf format arg1 arg2 ... but constructing a portable error.

Source

val tag : 
  ('a : value_or_null). 'a Base.Or_error.t ->
  tag:string ->
  'a Base.Or_error.t @@ portable

tag t ~tag is Result.map_error t ~f:(Error.tag ~tag).

Source

val tag_s : 
  ('a : value_or_null). 'a Base.Or_error.t ->
  tag:Base.Or_error.Sexp.t ->
  'a Base.Or_error.t @@ portable

tag_s is like tag with a sexp tag.

Source

val tag_s_lazy : 
  ('a : value_or_null). 'a Base.Or_error.t ->
  tag:Base.Or_error.Sexp.t Base.Lazy.t ->
  'a Base.Or_error.t @@ portable

tag_s_lazy is like tag with a lazy sexp tag.

Source

val tag_arg : 
  ('a : value_or_null) ('b : value_or_null). 'a Base.Or_error.t ->
  string ->
  'b ->
  ('b -> Base.Or_error.Sexp.t) ->
  'a Base.Or_error.t @@ portable

tag_arg is like tag, with a tag that has a sexpable argument.

Source

val unimplemented : 
  ('a : value_or_null). string ->
  'a Base.Or_error.t @ portable @@ portable

For marking a given value as unimplemented. Typically combined with conditional compilation, where on some platforms the function is defined normally, and on some platforms it is defined as unimplemented. The supplied string should be the name of the function that is unimplemented.

Source

val map : 
  ('a : value_or_null) ('b : value_or_null). 'a Base.Or_error.t ->
  f:('a -> 'b) @ local ->
  'b Base.Or_error.t @@ portable

Source

val iter : 
  ('a : value_or_null). 'a Base.Or_error.t ->
  f:('a -> unit) @ local ->
  unit @@ portable

Source

val iter_error : 
  ('a : value_or_null). 'a Base.Or_error.t ->
  f:(Base.Error.t -> unit) @ local ->
  unit @@ portable

Source

val combine_errors : 
  ('a : value_or_null). 'a Base.Or_error.t list ->
  'a list Base.Or_error.t @@ portable

combine_errors ts returns Ok if every element in ts is Ok, else it returns Error with all the errors in ts. More precisely:

combine_errors [Ok a1; ...; Ok an] = Ok [a1; ...; an]

  combine_errors [...; Error e1; ...; Error en; ...]
  = Error (Error.of_list [e1; ...; en])

Source

val combine_errors_unit : 
  unit Base.Or_error.t list ->
  unit Base.Or_error.t @@ portable

combine_errors_unit ts returns Ok if every element in ts is Ok (), else it returns Error with all the errors in ts, like combine_errors.

Source

val filter_ok_at_least_one : 
  ('a : value_or_null). 'a Base.Or_error.t list ->
  'a list Base.Or_error.t @@ portable

filter_ok_at_least_one ts returns all values in ts that are Ok if there is at least one, otherwise it returns the same error as combine_errors ts. Returns a bespoke error when passed an empty list.

Source

val find_ok : 
  ('a : value_or_null). 'a Base.Or_error.t list ->
  'a Base.Or_error.t @@ portable

find_ok ts returns the first value in ts that is Ok, otherwise it returns the same error as combine_errors ts.

Source

val find_map_ok : 
  ('a : value_or_null) ('b : value_or_null). 'a list ->
  f:('a -> 'b Base.Or_error.t) @ local ->
  'b Base.Or_error.t @@ portable

find_map_ok l ~f returns the first value in l for which f returns Ok, otherwise it returns the same error as combine_errors (List.map l ~f). Returns a bespoke error when passed an empty list.

Module Base.Or_errorSource

Module `Base.Or_error`Source