Pretty (pretty.Pretty)

module Types : sig ... end

include module type of Types

type simple = (unit, Stdlib.Format.formatter, unit) Stdlib.format

type ('a, 'b) func =
  ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 ->
  'a

type 'a proc = ('a, Stdlib.Format.formatter, unit) Stdlib.format -> 'a

type 'a printer = Stdlib.Format.formatter -> 'a -> unit

type 'a formatting = Stdlib.Format.formatter -> 'a

type delayed = unit formatting

val print : Stdlib.Format.formatter -> 'a proc

val out : 'a proc

val error : 'a proc

val sink : 'a proc

val delayed : ('a, delayed) func

val delayed_to : (delayed -> 'b) -> ('a, 'b) func

val pp_set_margin : Stdlib.Format.formatter -> int -> unit

val blast_margin : Stdlib.Format.formatter -> unit

val to_string : ('a, string) func

val string_to : (string -> 'b) -> ('a, 'b) func

val failwith : ('a, 'b) func

val invalid_arg : ('a, 'b) func

val styles : Fmt.style list -> 'a printer -> 'a printer

val char : char printer

val string : string printer

val text : string printer

val int64 : int64 printer

val option : 'a printer -> 'a option printer

val list : 
  ?fopen:simple ->
  ?fsep:simple ->
  ?fclose:simple ->
  ?fempty:simple ->
  'a printer ->
  'a list printer

val stack : 'a printer -> 'a list printer

val path : string list printer

val with_oxford_comma : ?comb:string -> 'a printer -> 'a list printer

with_oxford_comma ~comb pp ppf lst pretty-prints lst using ppf by enumerating its items and inserting Oxford-style comma. In particular, this function:

does nothing on an empty list;

acts like pp ppf e if lst = [e];

prints "a comb b" (without comma) in case lst = [a;b];

otherwise prints every element followed by a comma, except for the last that is preceded with "comb", as for instance in "a, b, c, and d".

comb is "and" by default; other sensible use is "or".

val record : 
  ?opening:'a printer ->
  ?closing:'a printer ->
  'a printer list ->
  'a printer

val delayed_record : 
  ?opening:unit printer ->
  ?closing:unit printer ->
  unit printer list ->
  delayed

val vfield : 
  ?label:string printer ->
  ?sep:unit printer ->
  string ->
  ('a -> 'b) ->
  'b printer ->
  'a printer

type 'a conditional_field =

| T of 'a printer
| C of 'a -> bool * 'a printer
| I of 'a -> bool * 'a printer * 'a printer
| C' of bool * 'a printer
| I' of bool * 'a printer * 'a printer

val record_with_conditional_fields : 
  ?opening:'a printer ->
  ?closing:'a printer ->
  'a conditional_field list ->
  'a printer

module Simple : sig ... end

val init_formatters : 
  ?style_renderer:Fmt.style_renderer ->
  ?utf_8:bool ->
  unit ->
  unit