package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module extends Base.Error with bin_io.

type t = private Base.Info.t

Serialization and comparison force the lazy message.

val compare : t -> t -> int
val equal : t -> t -> bool
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
val invariant : t -> unit
val to_string_hum : t -> string

to_string_hum forces the lazy message, which might be an expensive operation.

to_string_hum usually produces a sexp; however, it is guaranteed that to_string_hum (of_string s) = s.

If this string is going to go into a log file, you may find it useful to ensure that the string is only one line long. To do this, use to_string_mach t.

val to_string_mach : t -> string

to_string_mach t outputs t as a sexp on a single line.

val to_string_hum_deprecated : t -> string

Old version (pre 109.61) of to_string_hum that some applications rely on.

Calls should be replaced with to_string_mach t, which outputs more parentheses and backslashes.

val of_string : string -> t

Be careful that the body of the lazy or thunk does not access mutable data, since it will only be called at an undetermined later point.

val of_lazy : string Base.Lazy.t -> t
val of_lazy_sexp : Base.Sexp.t Base.Lazy.t -> t
val of_thunk : (unit -> string) -> t
val of_lazy_t : t Base.Lazy.t -> t
val create : ?here:Base__.Import.Caml.Lexing.position -> ?strict:unit -> string -> 'a -> ('a -> Base.Sexp.t) -> t

For create message a sexp_of_a, 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.

val create_s : Base.Sexp.t -> t
val createf : ('a, unit, string, t) Stdlib.format4 -> 'a

Constructs a t containing only a string from a format. This eagerly constructs the string.

val tag : t -> tag:string -> t

Adds a string to the front.

val tag_s : t -> tag:Base.Sexp.t -> t

Adds a sexp to the front.

val tag_s_lazy : t -> tag:Base.Sexp.t Base.Lazy.t -> t

Adds a lazy sexp to the front.

val tag_arg : t -> string -> 'a -> ('a -> Base.Sexp.t) -> t

Adds a string and some other data in the form of an s-expression at the front.

val of_list : ?trunc_after:int -> t list -> t

Combines multiple infos into one.

val of_exn : ?backtrace:[ `Get | `This of string ] -> exn -> t

of_exn and to_exn are primarily used with Error, but their definitions have to be here because they refer to the underlying representation.

~backtrace:`Get attaches the backtrace for the most recent exception. The same caveats as for Printexc.print_backtrace apply. ~backtrace:(`This s) attaches the backtrace s. The default is no backtrace.

val to_exn : t -> exn
val pp : Base.Formatter.t -> t -> unit
module Internal_repr = Base.Error.Internal_repr
val raise : t -> _

Note that the exception raised by this function maintains a reference to the t passed in.

val raise_s : Base.Sexp.t -> _
val to_info : t -> Base.Info.t
val of_info : Base.Info.t -> t

This include is the source of the bin_io functions.

include Bin_prot.Binable.S with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
module Stable : sig ... end

Error.t is not wire-compatible with Error.Stable.V1.t. See info.mli for details.

val failwiths : ?strict:Base.Unit.t -> here:Stdlib.Lexing.position -> Base.String.t -> 'a -> ('a -> Base.Sexp.t) -> _
failwiths ?strict ~here message a sexp_of_a
= Error.raise (Error.create ?strict ~here s a sexp_of_a)

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

In this signature we write ~here:Lexing.position rather than ~here:Source_code_position.t to avoid a circular dependency.

val failwithp : ?strict:Base.Unit.t -> Stdlib.Lexing.position -> Base.String.t -> 'a -> ('a -> Base.Sexp.t) -> _
  • deprecated [since 2020-03] Use [failwiths] instead.
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct