Module Logs.Tag

Message tags.

Message tags are arbitrary named and typed values that can be associated to log messages. See an example.

Tag definitions

type 'a def

The type for tag definitions. The type 'a is the type of the tag. The definition specifies a name for the tag, a pretty-printer for the type of the tag and a documentation string. See def.

type def_e =
| Def : 'a def -> def_e

The type for existential tag definitions.

val def : ?⁠doc:string -> string -> (Stdlib.Format.formatter -> 'a -> unit) -> 'a def

def ~doc name pp is a tag definition. name is the name of the tag, it doesn't need to be unique. pp is a printer for the type of the tag. doc is a documentation string describing the tag (defaults to "undocumented").

val name : 'a def -> string

name d is d's name.

val doc : 'a def -> string

doc d is d's documentation string.

val printer : 'a def -> Stdlib.Format.formatter -> 'a -> unit

printer d is d's type pretty-printer.

val pp_def : Stdlib.Format.formatter -> 'a def -> unit

pp_def ppf d prints an unspecified representation of d on ppf.

val list : unit -> def_e list

tag_list () is the list of currently existing tag definitions.

Tags

type t =
| V : 'a def * 'a -> t

The type for tags. Tuples the tag definition and its value.

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

pp ppf t prints an unspecified representation of t on ppf.

Tag sets

type set

The type for tag sets. A tag set contains at most one tag per tag definition.

val empty : set

empty is the empty set.

val is_empty : set -> bool

is_empty s is true iff s is empty.

val mem : 'a def -> set -> bool

mem d s is true iff s has a tag with definition d.

val add : 'a def -> 'a -> set -> set

add d v s is s with the tag (V (d, v)) added. If there was a tag with definition d in s it is replaced.

val rem : 'a def -> set -> set

rem d s is s without the tag defined by d (if there was one).

val find : 'a def -> set -> 'a option

find d s is the tag value with definition d in s (if any).

val get : 'a def -> set -> 'a

get d s is like find d s but

raises Invalid_argument

if there is no tag with definition d in s.

val fold : (t -> 'a -> 'a) -> set -> 'a -> 'a

fold f s acc is the result of folding f over the tags of s starting with acc.

val pp_set : Stdlib.Format.formatter -> set -> unit

pp_set ppf s prints an unspecified representation of s on ppf.