Module B0_std.FmtSource

Textual formatters.

Helpers for dealing with Format.

Standard outputs

stdout outputs to standard output.

stderr outputs to standard error.

Formatting

Sourceval pf : Format.formatter -> ('a, Format.formatter, unit) format -> 'a

pf is Format.fprintf.

Sourceval pr : ('a, Format.formatter, unit) format -> 'a

pf is Format.printf.

Sourceval epr : ('a, Format.formatter, unit) format -> 'a

epr is Format.eprintf.

Sourceval str : ('a, Format.formatter, unit, string) format4 -> 'a

str is Format.asprintf.

Sourceval kpf : (Format.formatter -> 'a) -> Format.formatter -> ('b, Format.formatter, unit, 'a) format4 -> 'b

kpf is Format.kfprintf.

Sourceval kstr : (string -> 'a) -> ('b, Format.formatter, unit, 'a) format4 -> 'b

kstr is Format.kasprintf.

Sourceval failwith : ('b, Format.formatter, unit, 'a) format4 -> 'b

failwith fmt ... is kstr failwith fmt ...

Sourceval failwith_notrace : ('b, Format.formatter, unit, 'a) format4 -> 'b

failwith_notrace is like failwith but Failure is raised with raise_notrace.

Sourceval invalid_arg : ('b, Format.formatter, unit, 'a) format4 -> 'b

invalid_arg fmt ... is kstr invalid_arg fmt ...

Sourceval error : ('b, Format.formatter, unit, ('a, string) result) format4 -> 'b

error fmt ... is kstr (fun s -> Error s) fmt ...

Formatters

Sourcetype 'a t = Format.formatter -> 'a -> unit

The type for formatter of values of type 'a.

Sourceval flush : 'a t

flush has the effect of Format.pp_print_flush.

Sourceval flush_nl : 'a t

flush_nl has the effect of Format.pp_print_newline.

Sourceval nop : 'a t

nop formats nothing.

Sourceval any : (unit, Format.formatter, unit) format -> 'a t

any fmt formats any value with fmt.

Sourceval using : ('a -> 'b) -> 'b t -> 'a t

using f pp ppf v is pp ppf (f v).

Separators

Sourceval cut : 'a t

cut has the effect of Format.pp_print_cut.

Sourceval sp : 'a t

sp has the effect of Format.pp_print_space.

Sourceval sps : int -> 'a t

sps n has the effect of Format.pp_print_break n 0.

Sourceval comma : 'a t

comma is Fmt.any ",@ ".

Sourceval semi : 'a t

semi is Fmt.any ";@ ".

Sequencing

Sourceval iter : ?sep:unit t -> (('a -> unit) -> 'b -> unit) -> 'a t -> 'b t

iter ~sep iter pp_elt formats the iterations of iter over a value using pp_elt. Iterations are separated by sep (defaults to cut).

Sourceval iter_bindings : ?sep:unit t -> (('a -> 'b -> unit) -> 'c -> unit) -> ('a * 'b) t -> 'c t

iter_bindings ~sep iter pp_binding formats the iterations of iter over a value using pp_binding. Iterations are separated by sep (defaults to cut).

Sourceval append : 'a t -> 'a t -> 'a t

append pp_v0 pp_v1 ppf v is pp_v0 ppf v; pp_v1 ppf v.

Sourceval (++) : 'a t -> 'a t -> 'a t

( ++ ) is append.

Sourceval concat : ?sep:unit t -> 'a t list -> 'a t

concat ~sep pps concatenates the formatters pps separating them with sep (defaults to cut).

Boxes

Sourceval box : ?indent:int -> 'a t -> 'a t

box ~indent pp ppf wraps pp in a horizontal or vertical box. Break hints that lead to a new line add indent to the current indentation (defaults to 0).

Sourceval hbox : 'a t -> 'a t

hbox is like box but is a horizontal box: the line is not split in this box (but may be in sub-boxes).

Sourceval vbox : ?indent:int -> 'a t -> 'a t

vbox is like box but is a vertical box: every break hint leads to a new line which adds indent to the current indentation (default to 0).

Sourceval hvbox : ?indent:int -> 'a t -> 'a t

hvbox is like box but is either hbox if its fits on a single line or vbox otherwise.

Sourceval hovbox : ?indent:int -> 'a t -> 'a t

hovbox is a condensed box, see Format.pp_open_hovbox.

Brackets

Sourceval parens : 'a t -> 'a t

parens pp_v ppf is pf "@[<1>(%a)@]" pp_v.

Sourceval brackets : 'a t -> 'a t

brackets pp_v ppf is pf "@[<1>[%a]@]" pp_v.

Sourceval braces : 'a t -> 'a t

braces pp_v ppf is pf "@[<1>{%a}@]" pp_v.

Sourceval quote : ?mark:string -> 'a t -> 'a t

quote ~mark pp_v ppf is pf "@[<1>@<1>%s%a@<1>%s@]" mark pp_v mark, mark defaults to "\"", it is always counted as spanning as single column (this allows for UTF-8 encoded marks).

Records

Sourceval id : 'a -> 'a

id is Fun.id.

Sourceval field : ?label:string t -> ?sep:unit t -> string -> ('b -> 'a) -> 'a t -> 'b t

field ~label ~sep l prj pp_v pretty prints a labelled field value as pf "@[<1>%a%a%a@]" label l sep () (using prj pp_v). label defaults to tty_string [`Yellow] and sep to any ":@ ".

Sourceval record : ?sep:unit t -> 'a t list -> 'a t

record ~sep fields pretty-prints a value using the concatenation of fields, separated by sep (defaults to cut) and framed in a vertical box.

Stdlib types

Formatters for structures give full control to the client over the formatting process and do not wrap the formatted structures with boxes.

Sourceval bool : bool t

bool is Format.pp_print_bool.

Sourceval int : int t

int is Format.pp_print_int.

Sourceval uint32 : int32 t

uint32 is pf ppf "%lu".

Sourceval int32 : int32 t

int32 is pf ppf "%ld".

Sourceval int64 : int64 t

int64 is pf ppf "%Ld".

Sourceval uint64 : int64 t

uint64 is pf ppf "%Lu".

Sourceval float : float t

float is pf ppf "%g".

Sourceval char : char t

char is Format.pp_print_char.

Sourceval string : string t

string is Format.pp_print_string.

Sourceval sys_signal : int t

sys_signal formats an OCaml signal number as a C POSIX constant or "SIG(%d)" if the signal number is unknown.

backtrace formats a backtrace.

Sourceval exn : exn t

exn formats an exception.

Sourceval exn_backtrace : (exn * Printexc.raw_backtrace) t

exn_backtrace formats an exception backtrace.

Sourceval pair : ?sep:unit t -> 'a t -> 'b t -> ('a * 'b) t

pair ~sep pp_fst pp_snd formats a pair. The first and second projection are formatted using pp_fst and pp_snd and are separated by sep (defaults to cut).

Sourceval option : ?none:unit t -> 'a t -> 'a option t

option ~none pp_v formats an option. The Some case uses pp_v and None uses none (defaults to nop).

Sourceval none : unit t

none is any "<none>".

Sourceval list : ?empty:unit t -> ?sep:unit t -> 'a t -> 'a list t

list ~sep pp_v formats list elements. Each element of the list is formatted in order with pp_v. Elements are separated by sep (defaults to cut). If the list is empty, this is empty (defaults to nop).

Sourceval array : ?empty:unit t -> ?sep:unit t -> 'a t -> 'a array t

array ~sep pp_v formats array elements. Each element of the array is formatted in in order with pp_v. Elements are seperated by sep (defaults to cut). If the array is empty this is empty (defauls to nop).

Magnitudes

Sourceval si_size : scale:int -> string -> int t

si_size ~scale unit formats a non negative integer representing unit unit at scale 10scale * 3, depending on its magnitude, using power of 3 SI prefixes (i.e. all of them except deca, hector, deci and centi). The output is UTF-8 encoded, it uses U+03BC for µ (10-6).

scale indicates the scale 10scale * 3 an integer represents, for example -1 for munit (10-3), 0 for unit (100), 1 for kunit (103); it must be in the range [-8;8] or Invalid_argument is raised.

Except at the maximal yotta scale always tries to show three digits of data with trailing fractional zeros omited. Rounds towards positive infinity (over approximates).

Sourceval byte_size : int t

byte_size is si_size ~scale:0 "B".

Sourceval uint64_ns_span : int64 t

uint64_ns_span formats an unsigned nanosecond time span according to its magnitude using SI prefixes on seconds and non-SI units. Years are counted in Julian years (365.25 SI-accepted days) as defined by the International Astronomical Union.

Rounds towards positive infinity, i.e. over approximates, no duration is formatter shorter than it is.

The output is UTF-8 encoded, it uses U+03BC for µs (10-6s).

Text and lines

Sourceval text : string t

text is Format.pp_print_text.

Sourceval lines : string t

lines formats lines by replacing newlines ('\n') in the string with calls to Format.pp_force_newline.

Sourceval truncated : max:int -> string t

truncated ~max formats a string using at most max characters. If the string doesn't fit, it is truncated and ended with … (U+2026) which does count towards max.

HCI fragments

Sourceval and_enum : ?empty:unit t -> 'a t -> 'a list t

and_enum ~empty pp_v ppf l formats l according to its length.

  • 0, formats empty (defaults to nop).
  • 1, formats the element with pp_v.
  • 2, formats "%a and %a" with the list elements
  • n, formats "%a, ... and %a" with the list elements
Sourceval or_enum : ?empty:unit t -> 'a t -> 'a list t

or_enum is like and_enum but uses "or" instead of "and".

Sourceval did_you_mean : 'a t -> 'a list t

did_you_mean pp_v formats "Did you mean %a ?" with or_enum if the list is non-empty and nop otherwise.

Sourceval must_be : 'a t -> 'a list t

must_be pp_v formats "Must be %a." with or_enum if the list is non-empty and nop otherwise.

Sourceval unknown : kind:unit t -> 'a t -> 'a t

unknown ~kind pp_v formats "Unknown %a %a." kind () pp_v.

Sourceval unknown' : kind:unit t -> 'a t -> hint:('a t -> 'a list t) -> ('a * 'a list) t

unknown ~kind pp_v ~hint (v, hints) formats unknown followed by a space and hint pp_v hints if hints is non-empty.

ANSI TTY styling

Sourceval set_tty_cap : ?cap:Tty.cap -> unit -> unit

set_tty_cap ?cap () sets the global TTY formatting capabilities to cap if specified and to Tty.(cap (of_fd Unix.stdout)) otherwise. . Affects the output of tty_str and tty.

Sourceval tty_cap : unit -> Tty.cap

tty_cap () is the global styling capability.

Sourceval tty_string : Tty.style list -> string t

tty_string styles ppf s prints s on ppf according to styles and the value of tty_styling_cap.

Sourceval tty : Tty.style list -> 'a t -> 'a t

tty styles pp_v ppf v prints v with pp_v on ppf according to styles and the value of tty_styling_cap.

Sourceval code : 'a t -> 'a t

code is tty `Bold.