Format_doc.Doc(3)                OCaml library               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




OCamldoc                          2025-01-20                 Format_doc.Doc(3)