Format_doc.Doc(3)

NAME
Format_doc.Doc - Definitions and immutable API for composing documents

Module
Module Format_doc.Doc

Documentation

Module Doc
 : sig end

Definitions and immutable API for composing documents

  Type definitions and core functions

type box_type =
 | H
 | V
 | HV
 | HoV
 | B

Format box types

type stag = Format.stag

type element =
 | Text of string
 | With_size of int
 | Open_box of {
 kind : box_type ;
 indent : int ;
 }
 | Close_box
 | Open_tag of Format.stag
 | Close_tag
 | Open_tbox
 | Tab_break of {
 width : int ;
 offset : int ;
 }
 | Set_tab
 | Close_tbox
 | Simple_break of {
 spaces : int ;
 indent : int ;
 }
 | Break of {
 fits : string * int * string ;
 breaks : string * int * string ;
 }
 | Flush of {
 newline : bool ;
 }
 | Newline
 | If_newline
 | Deprecated of (Format.formatter -> unit)
  (* Escape hatch: a Format printer used to provide backward-compatibility for user-defined printer (from the #install_printer toplevel directive for instance).
 *)

Base formatting instruction recognized by Format

type t

Immutable document type

type ('a, 'b) fmt = ('a, t, t, 'b) format4

type printer0 = t -> t

type 'a printer = 'a -> printer0

val empty : t

Empty document

val format : Format.formatter -> t -> unit

format ppf doc sends the format instruction of doc to the Format's formatter doc .

val fold : ('acc -> element -> 'acc) -> 'acc -> t -> 'acc

Fold over a document as a sequence of instructions

val msg : ('a, t) fmt -> 'a

Format_doc.Doc.msg and Format_doc.Doc.kmsg produce a document from a format string and its argument

val kmsg : (t -> 'b) -> ('a, 'b) fmt -> 'a

val printf : ('a, printer0) fmt -> 'a

Format_doc.Doc.printf and Format_doc.Doc.kprintf produce a printer from a format string and its argument

val kprintf : (t -> 'b) -> ('a, t -> 'b) fmt -> 'a

val open_box : box_type -> int -> printer0

The functions below mirror Format printers, without the pp_print_ prefix naming convention

val close_box : printer0

val text : string printer

val string : string printer

val bytes : bytes printer

val with_size : int printer

val int : int printer

val float : float printer

val char : char printer

val bool : bool printer

val space : printer0

val cut : printer0

val break : spaces:int -> indent:int -> printer0

val custom_break : fits:string * int * string -> breaks:string * int * string -> printer0

val force_newline : printer0

val if_newline : printer0

val flush : printer0

val force_stop : printer0

val open_tbox : printer0

val set_tab : printer0

val tab : printer0

val tab_break : width:int -> offset:int -> printer0

val close_tbox : printer0

val open_tag : stag printer

val close_tag : printer0

val list : ?sep:printer0 -> 'a printer -> 'a list printer

val iter : ?sep:printer0 -> iter:(('a -> unit) -> 'b -> unit) -> 'a printer -> 'b printer

val array : ?sep:printer0 -> 'a printer -> 'a array printer

val seq : ?sep:printer0 -> 'a printer -> 'a Seq.t printer

val option : ?none:printer0 -> 'a printer -> 'a option printer

val result : ok:'a printer -> error:'e printer -> ('a, 'e) result printer

val either : left:'a printer -> right:'b printer -> ('a, 'b) Either.t printer

  Alignment functions

val align_prefix : (t * int) list -> t list

Align the right side of one "@{<ralign>...@}" tag box by inserting spaces at the beginning of boxes. Those function do nothing if the tag box appears after a break hint.

val align_prefix2 : t * int -> t * int -> t * t