Error (imandrakit.Imandrakit

include module type of Error_core

type message = {

msg : string;
data : Data.t;
bt : string option;
(*
Backtrace
*)

}

A message.

An error message is emitted at a particular place in the code. An error can contain several error messages.

val message_to_twine : message Imandrakit_twine.Encode.encoder

val message_of_twine : message Imandrakit_twine.Decode.decoder

type stack = message list

type t = {

process : string;
kind : Kind.t;
msg : message;
stack : stack;

}

val pp : 
  Ppx_deriving_runtime.Format.formatter ->
  t ->
  Ppx_deriving_runtime.unit

val show : t -> Ppx_deriving_runtime.string

val to_twine : t Imandrakit_twine.Encode.encoder

val of_twine : t Imandrakit_twine.Decode.decoder

exception E of t

Internal error

val pp_with : show_process:bool -> t Imandrakit_common.Fmt.printer

module Message : sig ... end

val data : t -> Data.t

val get_data : 'a Data.key -> t -> 'a option

val raise_err : ?bt:Stdlib.Printexc.raw_backtrace -> t -> 'a

val add_bt : string -> t -> t

val add_ctx : message -> t -> t

val add_data : 'a Data.key -> 'a -> t -> t

val guard : ?let_pass:(exn -> bool) -> (unit -> message) -> (unit -> 'a) -> 'a

guard g f behaves like f(), excepts that if f() raises Error e, guard g f raises Error e' where e' wraps e with context error g().

parameter let_pass
if it returns true for an exception, the exception is re-raised.

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

val pp_result : 
  (Ppx_deriving_runtime.Format.formatter -> 'a -> Ppx_deriving_runtime.unit) ->
  Ppx_deriving_runtime.Format.formatter ->
  'a result ->
  Ppx_deriving_runtime.unit

val show_result : 
  (Ppx_deriving_runtime.Format.formatter -> 'a -> Ppx_deriving_runtime.unit) ->
  'a result ->
  Ppx_deriving_runtime.string

val map_result : ('a -> 'b) -> 'a result -> 'b result

val iter_result : 
  ('a -> Ppx_deriving_runtime.unit) ->
  'a result ->
  Ppx_deriving_runtime.unit

val result_to_twine : 
  'a Imandrakit_twine.Encode.encoder ->
  'a result Imandrakit_twine.Encode.encoder

val result_of_twine : 
  'a Imandrakit_twine.Decode.decoder ->
  'a result Imandrakit_twine.Decode.decoder

val unwrap : 'a result -> 'a

unwrap e uses raise_err to unpack the result

module Infix : sig ... end

include module type of Infix

val let*! : (unit -> message) -> (unit -> 'a) -> 'a

Similar to guard

module Kind = Kind

val fail : 
  ?stack:message list ->
  ?process:string ->
  ?bt:string ->
  kind:Kind.t ->
  string ->
  'a

fail "some error message" raises an error with the given message

val failf : 
  ?stack:message list ->
  ?process:string ->
  ?bt:string ->
  kind:Kind.t ->
  ('a, Stdlib.Format.formatter, unit, 'b) format4 ->
  'a

errorf "some error message %s (number %d)" "with formatting" 42 raises an error with the given formatted message

val mk_error : 
  ?stack:message list ->
  ?process:string ->
  ?bt:string ->
  kind:Kind.t ->
  string ->
  t

val mk_errorf : 
  ?stack:message list ->
  ?process:string ->
  ?bt:string ->
  kind:Kind.t ->
  ('a, Stdlib.Format.formatter, unit, t) format4 ->
  'a

val message : ?bt:string -> string -> message

val messagef : 
  ?bt:string ->
  ('a, Stdlib.Format.formatter, unit, message) format4 ->
  'a

val guards : ?let_pass:(exn -> bool) -> string -> (unit -> 'a) -> 'a

val guardf : 
  ?let_pass:(exn -> bool) ->
  ((('a, Stdlib.Format.formatter, unit, message) format4 -> 'a) -> message) ->
  (unit -> 'b) ->
  'b

guardf ~loc k f behaves like f(), but will call k to produce a contextual message in case of error.

val of_exn : ?bt:Stdlib.Printexc.raw_backtrace -> kind:Kind.t -> exn -> t

Turn exception into an error.

val try_catch : kind:Kind.t -> unit -> (unit -> 'a) -> 'a result

val unwrap_opt : 'a option -> 'a