package core_kernel

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

This module extends Base.Error with bin_io.

include Base.Info_intf.S with type t = private Base.Info.t
type t = private Base.Info.t

Serialization and comparison force the lazy message.

include sig ... end
val compare : t -> t -> int
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t -> t
val sexp_of_t : t -> Base.Sexp.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 parenthesis and backslashes.

val of_string : string -> t
val of_lazy : string Base.Lazy.t -> 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_thunk : (unit -> string) -> t
val create : ?here: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) Pervasives.format4 -> 'a

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

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

Add a string to the front.

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

Add 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

Combine 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.

val to_exn : t -> exn
val pp : Caml.Format.formatter -> 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 sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Base.Int.t -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
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: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.

The pa_fail preprocessor replaces failwiths with failwiths ?here:[%here] so that one does not need to (and cannot) supply [%here]. pa_fail does not add ?here:[%here] to Error.failwiths.

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

failwithp here is like failwiths ~here, except that you can provide a source position yourself (which is only interesting if you don't provide [%here]).

val failwithp : ?strict:Base.Unit.t -> Lexing.position -> Base.String.t -> 'a -> ('a -> Base.Sexp.t) -> _
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