include Sig.CORE
with type error := error
and type error_category := error_categoryval string_of_category : error_category -> stringval error_encoding : error Data_encoding.tThe encoding for errors.
Note that this encoding has a few peculiarities, some of which may impact your code. These peculiarities are due to the type error being an extensible variant.
Because the error type is an extensible variant, you must register an encoding for each error constructor you add to error. This is done via register_error_kind.
Because the error type is an extensible variant, with dynamically registered errors (see peculiarity above), there are no tags associated with each error. This does not affect the JSON encoding, but it does impose restrictions on the binary encoding. The chosen workaround is to encode errors as JSON and to encode the JSON to binary form. As a result, errors can be somewhat large in binary: they include field names and such.
Because the error type is an extensible variant, with dynamically registered errors (see peculiarity above), the encoding must be recomputed when a new error is registered. This is achieved by the means of a Data_encoding.delayed combinator: the encoding is recomputed on-demand. There is a caching mechanism so that, in the case where no new errors have been registered since the last use, the last result is used.
This last peculiarity imposes a limit on the use of error_encoding itself. Specifically, it is invalid to use error_encoding inside the ~json argument of a Data_encoding.splitted. This is because splitted evaluates the delayed combinator once-and-for-all to produce a json encoding. (Note that the following data-encoding combinators use splitted internally: Data_encoding.Compact.make, Data_encoding.assoc, and Data_encoding.lazy_encoding. As a result, it is invalid to use error_encoding within the arguments of these combinators as well.)
val pp : Stdlib.Format.formatter -> error -> unitval register_error_kind :
error_category ->
id:string ->
title:string ->
description:string ->
?pp:(Stdlib.Format.formatter -> 'err -> unit) ->
'err Data_encoding.t ->
(error -> 'err option) ->
('err -> error) ->
unitThe error data type is extensible. Each module can register specialized error serializers id unique name of this error. Ex.: overflow_time_counter title more readable name. Ex.: Overflow of time counter description human readable description. Ex.: The time counter overflowed while computing delta increase pp formatter used to pretty print additional arguments. Ex.: The time counter overflowed while computing delta increase. Previous value %d. Delta: %d encoder decoder data encoding for this error. If the error has no value, specify Data_encoding.empty
val classify_error : error -> Error_classification.tClassify an error using the registered kinds
Catch all error when 'serializing' an error.
Catch all error when 'deserializing' an error.
val json_of_error : error -> Data_encoding.jsonAn error serializer
val error_of_json : Data_encoding.json -> errortype error_info = {category : error_category;id : string;title : string;description : string;schema : Data_encoding.json_schema;}Error information
val pp_info : Stdlib.Format.formatter -> error_info -> unitval find_info_of_error : error -> error_infofind_info_of_error e retrieves the `error_info` associated with the given error `e`.
val get_registered_errors : unit -> error_info listRetrieves information of registered errors
include Sig.WITH_WRAPPED with type error := errormodule type Wrapped_error_monad = sig ... endThe purpose of this module is to wrap a specific error monad E into a more general error monad Eg.
val register_wrapped_error_kind :
(module Wrapped_error_monad) ->
id:string ->
title:string ->
description:string ->
unitSame as register_error_kind but for a wrapped error monad. The codec is defined in the module parameter. It makes the category of the error Wrapped instead of Main.