package b0

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

Textual formatters.

Helpers for dealing with Format.

Standard outputs

val stdout : Format.formatter

stdout outputs to standard output.

val stderr : Format.formatter

stderr outputs to standard error.

Formatting

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

pf is Format.fprintf.

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

pf is Format.printf.

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

epr is Format.eprintf.

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

str is Format.asprintf.

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

kpf is Format.kfprintf.

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

kstr is Format.kasprintf.

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

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

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

failwith_notrace is like failwith but Failure is raised with raise_notrace.

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

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

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

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

Formatters

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

The type for formatter of values of type 'a.

val flush : 'a t

flush has the effect of Format.pp_print_flush.

val flush_nl : 'a t

flush_nl has the effect of Format.pp_print_newline.

val nop : 'a t

nop formats nothing.

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

any fmt formats any value with fmt.

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

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

Separators

val cut : 'a t

cut has the effect of Format.pp_print_cut.

val sp : 'a t

sp has the effect of Format.pp_print_space.

val sps : int -> 'a t

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

val comma : 'a t

comma is Fmt.any ",@ ".

val semi : 'a t

semi is Fmt.any ";@ ".

Sequencing

val 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).

val 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).

val append : 'a t -> 'a t -> 'a t

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

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

( ++ ) is append.

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

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

Boxes

val 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).

val 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).

val 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).

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

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

hovbox is a condensed box, see Format.pp_open_hovbox.

Brackets

val parens : 'a t -> 'a t

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

val brackets : 'a t -> 'a t

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

val braces : 'a t -> 'a t

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

val 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

val id : 'a -> 'a

id is Fun.id.

val 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 ":@ ".

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

val bool : bool t

bool is Format.pp_print_bool.

val int : int t

int is Format.pp_print_int.

val int32 : int32 t

int32 is pf ppf "%ld".

val int64 : int64 t

int64 is pf ppf "%Ld".

val float : float t

float is pf ppf "%g".

val char : char t

char is Format.pp_print_char.

val string : string t

string is Format.pp_print_string.

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

val backtrace : Printexc.raw_backtrace t

backtrace formats a backtrace.

val exn : exn t

exn formats an exception.

val exn_backtrace : (exn * Printexc.raw_backtrace) t

exn_backtrace formats an exception backtrace.

val 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).

val 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).

val none : unit t

none is any "<none>".

val 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).

val 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

val 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). Only US-ASCII characters are used, µ (10-6) is written using u.

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

val byte_size : int t

byte_size is si_size ~scale:0 "B".

val uint64_ns_span : int64 t

uint64_ns_span formats an unsigned nanosecond time span according to its magnitude using SI prefixes on seconds and accepted non-SI units. Years are counted in Julian years (365.25 SI-accepted days) as defined by the International Astronomical Union (IAU). Only US-ASCII characters are used (us is used for µs).

Text and lines

val text : string t

text is Format.pp_print_text.

val lines : string t

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

val 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 three consecutive dots which do count towards max.

HCI fragments

val 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
val or_enum : ?empty:unit t -> 'a t -> 'a list t

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

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

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

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

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

val 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

val set_tty_styling_cap : Tty.cap -> unit

set_tty_styling_cap c sets the global styling capabilities to c. Affects the output of tty_str and tty.

val tty_styling_cap : unit -> Tty.cap

tty_styling_cap () is the global styling capability.

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

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

val code : 'a t -> 'a t

code is tty `Bold.

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