package core_kernel

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

This module extends Base.Info, which provides a type for info-level debug messages.

include module type of struct include Base.Info end with module Internal_repr := Base.Info.Internal_repr
module type S = Info.S
include S with module Internal_repr := Base.Info.Internal_repr
type t

Serialization and comparison force the lazy message.

val compare : t -> t -> int
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Base.Sexpable.S with type t := t
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 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_thunk : (unit -> string) -> t
val of_lazy_t : t Base.Lazy.t -> 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) 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_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 : sig ... end
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
module Extend (Info : Base.Info.S) : sig ... end
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