Module Stdune.Pp

Pretty printers

type +'tag t

A document that is not yet rendered. The argument is the type of tags in the document. For instance tags might be used for styles.

Basic combinators

val nop : _ t

A pretty printer that prints nothing

val seq : 'a t -> 'a t -> 'a t

seq x y prints x and then y

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

concat ?sep l prints elements in l separated by sep. sep defaults to nop.

val concat_map : ?⁠sep:'a t -> 'b list -> f:('b -> 'a t) -> 'a t

Convenience function for List.map followed by concat

val concat_mapi : ?⁠sep:'a t -> 'b list -> f:(int -> 'b -> 'a t) -> 'a t
val verbatim : string -> _ t

An indivisible block of text

val char : char -> _ t

A single character

val text : string -> _ t

Print a bunch of text. The line may be broken at any spaces in the text.

val textf : ('a, unit, string, _ t) Stdlib.format4 -> 'a

Same as text but take a format string as argument.

val tag : 'a -> 'a t -> 'a t

tag x t Tag the material printed by t with x

Break hints

val space : _ t

Either a newline or a space, depending on whether the line is broken at this point.

val cut : _ t

Either a newline or nothing, depending on whether the line is broken at this point.

val break : nspaces:int -> shift:int -> _ t

Either a newline or nspaces spaces. If it is a newline, shift is added to the indentation level.

val newline : _ t

Force a newline to be printed

val map_tags : 'a t -> f:('a -> 'b) -> 'b t

Convert tags in a documents

val filter_map_tags : 'a t -> f:('a -> 'b option) -> 'b t

Boxes

val box : ?⁠indent:int -> 'a t -> 'a t

Try to put as much as possible on each line. Additionally, a break hint always break the line if the breaking would reduce the indentation level (break with negative shift value).

val vbox : ?⁠indent:int -> 'a t -> 'a t

Always break the line when encountering a break hint.

val hbox : 'a t -> 'a t

Print everything on one line, no matter what

val hvbox : ?⁠indent:int -> 'a t -> 'a t

If possible, print everything on one line. Otherwise, behave as a vbox

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

Try to put as much as possible on each line.

Common convenience functions

val enumerate : 'a list -> f:('a -> 'b t) -> 'b t

enumerate l ~f produces an enumeration of the form:

- item1 - item2 - item3 ...
val chain : 'a list -> f:('a -> 'b t) -> 'b t

chain l ~f is used to print a succession of items that follow each other. It produces an output of this form:

item1 -> item2 -> item3 ...

Operators

module O : sig ... end

Rendering

val render : Stdlib.Format.formatter -> 'a t -> tag_handler:(Stdlib.Format.formatter -> 'a -> 'a t -> unit) -> unit

Render a document to a classic formatter

val render_ignore_tags : Stdlib.Format.formatter -> 'a t -> unit