1Stdlib.Format(3) OCaml library Stdlib.Format(3)
2
6 Stdlib.Format - no description
7
9 Module Stdlib.Format
10
12 Module Format
13 : (module Stdlib__Format)
14 Introduction
24 You may consider this module as providing an extension to the printf
25 facility to provide automatic line splitting. The addition of
26 pretty-printing annotations to your regular printf format strings gives
27 you fancy indentation and line breaks. Pretty-printing annotations are
28 described below in the documentation of the function Format.fprintf .
29 You may also use the explicit pretty-printing box management and print‐
31 ing functions provided by this module. This style is more basic but
32 more verbose than the concise fprintf format strings.
33 For instance, the sequence open_box 0; print_string "x ="; print_space
35 ();
36 print_int 1; close_box (); print_newline () that prints x = 1
37 within a pretty-printing box, can be abbreviated as printf "@[%s@
38 %i@]@." "x =" 1 , or even shorter printf "@[x =@ %i@]@." 1 .
39 Rule of thumb for casual users of this library:
41 -use simple pretty-printing boxes (as obtained by open_box 0 );
43 -use simple break hints as obtained by print_cut () that outputs a sim‐
45 ple break hint, or by print_space () that outputs a space indicating a
46 break hint;
47 -once a pretty-printing box is open, display its material with basic
49 printing functions (e. g. print_int and print_string );
50 -when the material for a pretty-printing box has been printed, call
52 close_box () to close the box;
53 -at the end of pretty-printing, flush the pretty-printer to display all
55 the remaining material, e.g. evaluate print_newline () .
56 The behavior of pretty-printing commands is unspecified if there is no
58 open pretty-printing box. Each box opened by one of the open_ functions
59 below must be closed using close_box for proper formatting. Otherwise,
60 some of the material printed in the boxes may not be output, or may be
61 formatted incorrectly.
62 In case of interactive use, each phrase is executed in the initial
64 state of the standard pretty-printer: after each phrase execution, the
65 interactive system closes all open pretty-printing boxes, flushes all
66 pending text, and resets the standard pretty-printer.
67 Warning: mixing calls to pretty-printing functions of this module with
69 calls to Stdlib low level output functions is error prone.
70 The pretty-printing functions output material that is delayed in the
72 pretty-printer queue and stacks in order to compute proper line split‐
73 ting. In contrast, basic I/O output functions write directly in their
74 output device. As a consequence, the output of a basic I/O function may
75 appear before the output of a pretty-printing function that has been
76 called before. For instance,
77 Stdlib.print_string "<";
78 Format.print_string "PRETTY";
79 Stdlib.print_string ">";
80 Format.print_string "TEXT";
81 leads to output <>PRETTYTEXT .
82 Formatters
84 type formatter
85 Abstract data corresponding to a pretty-printer (also called a format‐
88 ter) and all its machinery. See also Format.formatter .
89 Pretty-printing boxes
94 The pretty-printing engine uses the concepts of pretty-printing box and
95 break hint to drive indentation and line splitting behavior of the
96 pretty-printer.
97 Each different pretty-printing box kind introduces a specific line
99 splitting policy:
100 -within an horizontal box, break hints never split the line (but the
103 line may be split in a box nested deeper),
104 -within a vertical box, break hints always split the line,
106 -within an horizontal/vertical box, if the box fits on the current line
108 then break hints never split the line, otherwise break hint always
109 split the line,
110 -within a compacting box, a break hint never splits the line, unless
112 there is no more room on the current line.
113 Note that line splitting policy is box specific: the policy of a box
115 does not rule the policy of inner boxes. For instance, if a vertical
116 box is nested in an horizontal box, all break hints within the vertical
117 box will split the line.
118 Moreover, opening a box after the Format.maxindent splits the line
120 whether or not the box would end up fitting on the line.
121 val pp_open_box : formatter -> int -> unit
123 val open_box : int -> unit
128 pp_open_box ppf d opens a new compacting pretty-printing box with off‐
131 set d in the formatter ppf .
132 Within this box, the pretty-printer prints as much as possible material
134 on every line.
135 A break hint splits the line if there is no more room on the line to
137 print the remainder of the box.
138 Within this box, the pretty-printer emphasizes the box structure: if a
140 structural box does not fit fully on a simple line, a break hint also
141 splits the line if the splitting ``moves to the left'' (i.e. the new
142 line gets an indentation smaller than the one of the current line).
143 This box is the general purpose pretty-printing box.
145 If the pretty-printer splits the line in the box, offset d is added to
147 the current indentation.
148 val pp_close_box : formatter -> unit -> unit
152 val close_box : unit -> unit
157 Closes the most recently open pretty-printing box.
159 val pp_open_hbox : formatter -> unit -> unit
163 val open_hbox : unit -> unit
168 pp_open_hbox ppf () opens a new 'horizontal' pretty-printing box.
171 This box prints material on a single line.
173 Break hints in a horizontal box never split the line. (Line splitting
175 may still occur inside boxes nested deeper).
176 val pp_open_vbox : formatter -> int -> unit
180 val open_vbox : int -> unit
185 pp_open_vbox ppf d opens a new 'vertical' pretty-printing box with off‐
188 set d .
189 This box prints material on as many lines as break hints in the box.
191 Every break hint in a vertical box splits the line.
193 If the pretty-printer splits the line in the box, d is added to the
195 current indentation.
196 val pp_open_hvbox : formatter -> int -> unit
200 val open_hvbox : int -> unit
205 pp_open_hvbox ppf d opens a new 'horizontal/vertical' pretty-printing
208 box with offset d .
209 This box behaves as an horizontal box if it fits on a single line, oth‐
211 erwise it behaves as a vertical box.
212 If the pretty-printer splits the line in the box, d is added to the
214 current indentation.
215 val pp_open_hovbox : formatter -> int -> unit
219 val open_hovbox : int -> unit
224 pp_open_hovbox ppf d opens a new 'horizontal-or-vertical' pretty-print‐
227 ing box with offset d .
228 This box prints material as much as possible on every line.
230 A break hint splits the line if there is no more room on the line to
232 print the remainder of the box.
233 If the pretty-printer splits the line in the box, d is added to the
235 current indentation.
236 Formatting functions
241 val pp_print_string : formatter -> string -> unit
242 val print_string : string -> unit
247 pp_print_string ppf s prints s in the current pretty-printing box.
250 val pp_print_bytes : formatter -> bytes -> unit
254 val print_bytes : bytes -> unit
259 pp_print_bytes ppf b prints b in the current pretty-printing box.
262 Since 4.13.0
265 val pp_print_as : formatter -> int -> string -> unit
269 val print_as : int -> string -> unit
274 pp_print_as ppf len s prints s in the current pretty-printing box. The
277 pretty-printer formats s as if it were of length len .
278 val pp_print_int : formatter -> int -> unit
282 val print_int : int -> unit
287 Print an integer in the current pretty-printing box.
289 val pp_print_float : formatter -> float -> unit
293 val print_float : float -> unit
298 Print a floating point number in the current pretty-printing box.
300 val pp_print_char : formatter -> char -> unit
304 val print_char : char -> unit
309 Print a character in the current pretty-printing box.
311 val pp_print_bool : formatter -> bool -> unit
315 val print_bool : bool -> unit
320 Print a boolean in the current pretty-printing box.
322 Break hints
327 A 'break hint' tells the pretty-printer to output some space or split
328 the line whichever way is more appropriate to the current pretty-print‐
329 ing box splitting rules.
330 Break hints are used to separate printing items and are mandatory to
332 let the pretty-printer correctly split lines and indent items.
333 Simple break hints are:
335 -the 'space': output a space or split the line if appropriate,
337 -the 'cut': split the line if appropriate.
339 Note: the notions of space and line splitting are abstract for the
341 pretty-printing engine, since those notions can be completely redefined
342 by the programmer. However, in the pretty-printer default setting,
343 ``output a space'' simply means printing a space character (ASCII code
344 32) and ``split the line'' means printing a newline character (ASCII
345 code 10).
346 val pp_print_space : formatter -> unit -> unit
348 val print_space : unit -> unit
353 pp_print_space ppf () emits a 'space' break hint: the pretty-printer
356 may split the line at this point, otherwise it prints one space.
357 pp_print_space ppf () is equivalent to pp_print_break ppf 1 0 .
360 val pp_print_cut : formatter -> unit -> unit
364 val print_cut : unit -> unit
369 pp_print_cut ppf () emits a 'cut' break hint: the pretty-printer may
372 split the line at this point, otherwise it prints nothing.
373 pp_print_cut ppf () is equivalent to pp_print_break ppf 0 0 .
376 val pp_print_break : formatter -> int -> int -> unit
380 val print_break : int -> int -> unit
385 pp_print_break ppf nspaces offset emits a 'full' break hint: the
388 pretty-printer may split the line at this point, otherwise it prints
389 nspaces spaces.
390 If the pretty-printer splits the line, offset is added to the current
392 indentation.
393 val pp_print_custom_break : formatter -> fits:string * int * string ->
397 breaks:string * int * string -> unit
398 pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4) emits a
401 custom break hint: the pretty-printer may split the line at this point.
402 If it does not split the line, then the s1 is emitted, then n spaces,
404 then s2 .
405 If it splits the line, then it emits the s3 string, then an indent (ac‐
407 cording to the box rules), then an offset of m spaces, then the s4
408 string.
409 While n and m are handled by formatter_out_functions.out_indent , the
411 strings will be handled by formatter_out_functions.out_string . This
412 allows for a custom formatter that handles indentation distinctly, for
413 example, outputs <br/> tags or entities.
414 The custom break is useful if you want to change which visible
416 (non-whitespace) characters are printed in case of break or no break.
417 For example, when printing a list
418 [a; b; c]
419 trailing semicolon when it is printed vertically:
420 [
423 a;
424 b;
425 c;
426 ]
427 You can do this as follows:
430 printf "@[<v 0>[@;<0 2>@[<v 0>a;@,b;@,c@]%t]@]@\n"
431 (pp_print_custom_break ~fits:("", 0, "") ~breaks:(";", 0, ""))
432 Since 4.08.0
436 val pp_force_newline : formatter -> unit -> unit
440 val force_newline : unit -> unit
445 Force a new line in the current pretty-printing box.
447 The pretty-printer must split the line at this point,
449 Not the normal way of pretty-printing, since imperative line splitting
451 may interfere with current line counters and box size calculation. Us‐
452 ing break hints within an enclosing vertical box is a better alterna‐
453 tive.
454 val pp_print_if_newline : formatter -> unit -> unit
458 val print_if_newline : unit -> unit
463 Execute the next formatting command if the preceding line has just been
465 split. Otherwise, ignore the next formatting command.
466 Pretty-printing termination
471 val pp_print_flush : formatter -> unit -> unit
472 val print_flush : unit -> unit
477 End of pretty-printing: resets the pretty-printer to initial state.
479 All open pretty-printing boxes are closed, all pending text is printed.
481 In addition, the pretty-printer low level output device is flushed to
482 ensure that all pending text is really displayed.
483 Note: never use print_flush in the normal course of a pretty-printing
485 routine, since the pretty-printer uses a complex buffering machinery to
486 properly indent the output; manually flushing those buffers at random
487 would conflict with the pretty-printer strategy and result to poor ren‐
488 dering.
489 Only consider using print_flush when displaying all pending material is
491 mandatory (for instance in case of interactive use when you want the
492 user to read some text) and when resetting the pretty-printer state
493 will not disturb further pretty-printing.
494 Warning: If the output device of the pretty-printer is an output chan‐
496 nel, repeated calls to print_flush means repeated calls to flush to
497 flush the out channel; these explicit flush calls could foil the
498 buffering strategy of output channels and could dramatically impact ef‐
499 ficiency.
500 val pp_print_newline : formatter -> unit -> unit
504 val print_newline : unit -> unit
509 End of pretty-printing: resets the pretty-printer to initial state.
511 All open pretty-printing boxes are closed, all pending text is printed.
513 Equivalent to Format.print_flush followed by a new line. See corre‐
515 sponding words of caution for Format.print_flush .
516 Note: this is not the normal way to output a new line; the preferred
518 method is using break hints within a vertical pretty-printing box.
519 Margin
524 val pp_set_margin : formatter -> int -> unit
525 val set_margin : int -> unit
530 pp_set_margin ppf d sets the right margin to d (in characters): the
533 pretty-printer splits lines that overflow the right margin according to
534 the break hints given. Setting the margin to d means that the format‐
535 ting engine aims at printing at most d-1 characters per line. Nothing
536 happens if d is smaller than 2. If d is too large, the right margin is
537 set to the maximum admissible value (which is greater than 10 ^ 9 ).
538 If d is less than the current maximum indentation limit, the maximum
539 indentation limit is decreased while trying to preserve a minimal ratio
540 max_indent/margin>=50% and if possible the current difference margin -
541 max_indent .
542 See also Format.pp_set_geometry .
544 val pp_get_margin : formatter -> unit -> int
548 val get_margin : unit -> int
553 Returns the position of the right margin.
555 Maximum indentation limit
560 val pp_set_max_indent : formatter -> int -> unit
561 val set_max_indent : int -> unit
566 pp_set_max_indent ppf d sets the maximum indentation limit of lines to
569 d (in characters): once this limit is reached, new pretty-printing
570 boxes are rejected to the left, unless the enclosing box fully fits on
571 the current line. As an illustration,
572 set_margin 10; set_max_indent 5; printf "@[123456@[7@]89A@]@."
573 yields
574 123456
575 789A
576 because the nested box "@[7@]" is opened after the maximum indentation
578 limit ( 7>5 ) and its parent box does not fit on the current line. Ei‐
579 ther decreasing the length of the parent box to make it fit on a line:
580 printf "@[123456@[7@]89@]@."
581 or opening an intermediary box before the maximum indentation limit
582 which fits on the current line
583 printf "@[123@[456@[7@]89@]A@]@."
584 avoids the rejection to the left of the inner boxes and print respec‐
585 tively "123456789" and "123456789A" . Note also that vertical boxes
586 never fit on a line whereas horizontal boxes always fully fit on the
587 current line. Opening a box may split a line whereas the contents may
588 have fit. If this behavior is problematic, it can be curtailed by set‐
589 ting the maximum indentation limit to margin - 1 . Note that setting
590 the maximum indentation limit to margin is invalid.
591 Nothing happens if d is smaller than 2.
593 If d is too large, the limit is set to the maximum admissible value
595 (which is greater than 10 ^ 9 ).
596 If d is greater or equal than the current margin, it is ignored, and
598 the current maximum indentation limit is kept.
599 See also Format.pp_set_geometry .
601 val pp_get_max_indent : formatter -> unit -> int
605 val get_max_indent : unit -> int
610 Return the maximum indentation limit (in characters).
612 Geometry
617 Geometric functions can be used to manipulate simultaneously the cou‐
618 pled variables, margin and maxixum indentation limit.
619 type geometry = {
621 max_indent : int ;
622 margin : int ;
623 }
624 val check_geometry : geometry -> bool
630 Check if the formatter geometry is valid: 1 < max_indent < margin
632 val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit
637 val set_geometry : max_indent:int -> margin:int -> unit
642 val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int ->
647 unit
648 val safe_set_geometry : max_indent:int -> margin:int -> unit
653 pp_set_geometry ppf ~max_indent ~margin sets both the margin and maxi‐
656 mum indentation limit for ppf .
657 When 1 < max_indent < margin , pp_set_geometry ppf ~max_indent ~margin
659 is equivalent to pp_set_margin ppf margin; pp_set_max_indent ppf
660 max_indent ; and avoids the subtly incorrect pp_set_max_indent ppf
661 max_indent; pp_set_margin ppf margin ;
662 Outside of this domain, pp_set_geometry raises an invalid argument ex‐
664 ception whereas pp_safe_set_geometry does nothing.
665 Since 4.08.0
668 val pp_update_geometry : formatter -> (geometry -> geometry) -> unit
672 pp_update_geometry ppf (fun geo -> { geo with ... }) lets you update a
675 formatter's geometry in a way that is robust to extension of the geome‐
676 try record with new fields.
677 Raises an invalid argument exception if the returned geometry does not
679 satisfy Format.check_geometry .
680 Since 4.11.0
683 val update_geometry : (geometry -> geometry) -> unit
687 val pp_get_geometry : formatter -> unit -> geometry
692 val get_geometry : unit -> geometry
697 Return the current geometry of the formatter
699 Since 4.08.0
702 Maximum formatting depth
707 The maximum formatting depth is the maximum number of pretty-printing
708 boxes simultaneously open.
709 Material inside boxes nested deeper is printed as an ellipsis (more
711 precisely as the text returned by Format.get_ellipsis_text () ).
712 val pp_set_max_boxes : formatter -> int -> unit
714 val set_max_boxes : int -> unit
719 pp_set_max_boxes ppf max sets the maximum number of pretty-printing
722 boxes simultaneously open.
723 Material inside boxes nested deeper is printed as an ellipsis (more
725 precisely as the text returned by Format.get_ellipsis_text () ).
726 Nothing happens if max is smaller than 2.
728 val pp_get_max_boxes : formatter -> unit -> int
732 val get_max_boxes : unit -> int
737 Returns the maximum number of pretty-printing boxes allowed before el‐
739 lipsis.
740 val pp_over_max_boxes : formatter -> unit -> bool
744 val over_max_boxes : unit -> bool
749 Tests if the maximum number of pretty-printing boxes allowed have al‐
751 ready been opened.
752 Tabulation boxes
757 A tabulation box prints material on lines divided into cells of fixed
758 length. A tabulation box provides a simple way to display vertical col‐
759 umns of left adjusted text.
760 This box features command set_tab to define cell boundaries, and com‐
762 mand print_tab to move from cell to cell and split the line when there
763 is no more cells to print on the line.
764 Note: printing within tabulation box is line directed, so arbitrary
766 line splitting inside a tabulation box leads to poor rendering. Yet,
767 controlled use of tabulation boxes allows simple printing of columns
768 within module Format .
769 val pp_open_tbox : formatter -> unit -> unit
771 val open_tbox : unit -> unit
776 open_tbox () opens a new tabulation box.
779 This box prints lines separated into cells of fixed width.
781 Inside a tabulation box, special tabulation markers defines points of
783 interest on the line (for instance to delimit cell boundaries). Func‐
784 tion Format.set_tab sets a tabulation marker at insertion point.
785 A tabulation box features specific tabulation breaks to move to next
787 tabulation marker or split the line. Function Format.print_tbreak
788 prints a tabulation break.
789 val pp_close_tbox : formatter -> unit -> unit
793 val close_tbox : unit -> unit
798 Closes the most recently opened tabulation box.
800 val pp_set_tab : formatter -> unit -> unit
804 val set_tab : unit -> unit
809 Sets a tabulation marker at current insertion point.
811 val pp_print_tab : formatter -> unit -> unit
815 val print_tab : unit -> unit
820 print_tab () emits a 'next' tabulation break hint: if not already set
823 on a tabulation marker, the insertion point moves to the first tabula‐
824 tion marker on the right, or the pretty-printer splits the line and in‐
825 sertion point moves to the leftmost tabulation marker.
826 It is equivalent to print_tbreak 0 0 .
828 val pp_print_tbreak : formatter -> int -> int -> unit
832 val print_tbreak : int -> int -> unit
837 print_tbreak nspaces offset emits a 'full' tabulation break hint.
840 If not already set on a tabulation marker, the insertion point moves to
842 the first tabulation marker on the right and the pretty-printer prints
843 nspaces spaces.
844 If there is no next tabulation marker on the right, the pretty-printer
846 splits the line at this point, then insertion point moves to the left‐
847 most tabulation marker of the box.
848 If the pretty-printer splits the line, offset is added to the current
850 indentation.
851 Ellipsis
856 val pp_set_ellipsis_text : formatter -> string -> unit
857 val set_ellipsis_text : string -> unit
862 Set the text of the ellipsis printed when too many pretty-printing
864 boxes are open (a single dot, . , by default).
865 val pp_get_ellipsis_text : formatter -> unit -> string
869 val get_ellipsis_text : unit -> string
874 Return the text of the ellipsis.
876 Semantic tags
881 type stag = ..
882 Semantic tags (or simply tags) are user's defined annotations to asso‐
885 ciate user's specific operations to printed entities.
886 Common usage of semantic tags is text decoration to get specific font
888 or text size rendering for a display device, or marking delimitation of
889 entities (e.g. HTML or TeX elements or terminal escape sequences).
890 More sophisticated usage of semantic tags could handle dynamic modifi‐
891 cation of the pretty-printer behavior to properly print the material
892 within some specific tags. For instance, we can define an RGB tag like
893 so:
894 type stag += RGB of {r:int;g:int;b:int}
895 In order to properly delimit printed entities, a semantic tag must be
898 opened before and closed after the entity. Semantic tags must be prop‐
899 erly nested like parentheses using Format.pp_open_stag and For‐
900 mat.pp_close_stag .
901 Tag specific operations occur any time a tag is opened or closed, At
903 each occurrence, two kinds of operations are performed tag-marking and
904 tag-printing:
905 -The tag-marking operation is the simpler tag specific operation: it
907 simply writes a tag specific string into the output device of the for‐
908 matter. Tag-marking does not interfere with line-splitting computation.
909 -The tag-printing operation is the more involved tag specific opera‐
911 tion: it can print arbitrary material to the formatter. Tag-printing is
912 tightly linked to the current pretty-printer operations.
913 Roughly speaking, tag-marking is commonly used to get a better render‐
915 ing of texts in the rendering device, while tag-printing allows fine
916 tuning of printing routines to print the same entity differently ac‐
917 cording to the semantic tags (i.e. print additional material or even
918 omit parts of the output).
919 More precisely: when a semantic tag is opened or closed then both and
921 successive 'tag-printing' and 'tag-marking' operations occur:
922 -Tag-printing a semantic tag means calling the formatter specific func‐
924 tion print_open_stag (resp. print_close_stag ) with the name of the
925 tag as argument: that tag-printing function can then print any regular
926 material to the formatter (so that this material is enqueued as usual
927 in the formatter queue for further line splitting computation).
928 -Tag-marking a semantic tag means calling the formatter specific func‐
930 tion mark_open_stag (resp. mark_close_stag ) with the name of the tag
931 as argument: that tag-marking function can then return the 'tag-opening
932 marker' (resp. `tag-closing marker') for direct output into the output
933 device of the formatter.
934 Being written directly into the output device of the formatter, seman‐
936 tic tag marker strings are not considered as part of the printing mate‐
937 rial that drives line splitting (in other words, the length of the
938 strings corresponding to tag markers is considered as zero for line
939 splitting).
940 Thus, semantic tag handling is in some sense transparent to
942 pretty-printing and does not interfere with usual indentation. Hence, a
943 single pretty-printing routine can output both simple 'verbatim' mate‐
944 rial or richer decorated output depending on the treatment of tags. By
945 default, tags are not active, hence the output is not decorated with
946 tag information. Once set_tags is set to true , the pretty-printer en‐
947 gine honors tags and decorates the output accordingly.
948 Default tag-marking functions behave the HTML way: Format.tag are en‐
950 closed in "<" and ">" while other tags are ignored; hence, opening
951 marker for tag string "t" is "<t>" and closing marker is "</t>" .
952 Default tag-printing functions just do nothing.
954 Tag-marking and tag-printing functions are user definable and can be
956 set by calling Format.set_formatter_stag_functions .
957 Semantic tag operations may be set on or off with Format.set_tags .
959 Tag-marking operations may be set on or off with Format.set_mark_tags .
960 Tag-printing operations may be set on or off with Format.set_print_tags
961 .
962 Since 4.08.0
965 type tag = string
968 type Format.stag +=
973 | String_tag of tag (* String_tag s is a string tag s . String tags
974 can be inserted either by explicitly using the constructor String_tag
975 or by using the dedicated format syntax "@{<s> ... @}" .
976 Since 4.08.0
979 *)
980 val pp_open_stag : formatter -> stag -> unit
986 val open_stag : stag -> unit
991 pp_open_stag ppf t opens the semantic tag named t .
994 The print_open_stag tag-printing function of the formatter is called
996 with t as argument; then the opening tag marker for t , as given by
997 mark_open_stag t , is written into the output device of the formatter.
998 Since 4.08.0
1001 val pp_close_stag : formatter -> unit -> unit
1005 val close_stag : unit -> unit
1010 pp_close_stag ppf () closes the most recently opened semantic tag t .
1013 The closing tag marker, as given by mark_close_stag t , is written into
1015 the output device of the formatter; then the print_close_stag
1016 tag-printing function of the formatter is called with t as argument.
1017 Since 4.08.0
1020 val pp_set_tags : formatter -> bool -> unit
1024 val set_tags : bool -> unit
1029 pp_set_tags ppf b turns on or off the treatment of semantic tags (de‐
1032 fault is off).
1033 val pp_set_print_tags : formatter -> bool -> unit
1037 val set_print_tags : bool -> unit
1042 pp_set_print_tags ppf b turns on or off the tag-printing operations.
1045 val pp_set_mark_tags : formatter -> bool -> unit
1049 val set_mark_tags : bool -> unit
1054 pp_set_mark_tags ppf b turns on or off the tag-marking operations.
1057 val pp_get_print_tags : formatter -> unit -> bool
1061 val get_print_tags : unit -> bool
1066 Return the current status of tag-printing operations.
1068 val pp_get_mark_tags : formatter -> unit -> bool
1072 val get_mark_tags : unit -> bool
1077 Return the current status of tag-marking operations.
1079 val pp_set_formatter_out_channel : formatter -> out_channel -> unit
1083 Redirecting the standard formatter output
1086 val set_formatter_out_channel : out_channel -> unit
1087 Redirect the standard pretty-printer output to the given channel. (All
1089 the output functions of the standard formatter are set to the default
1090 output functions printing to the given channel.)
1091 set_formatter_out_channel is equivalent to Format.pp_set_format‐
1094 ter_out_channel std_formatter .
1095 val pp_set_formatter_output_functions : formatter -> (string -> int ->
1099 int -> unit) -> (unit -> unit) -> unit
1100 val set_formatter_output_functions : (string -> int -> int -> unit) ->
1105 (unit -> unit) -> unit
1106 pp_set_formatter_output_functions ppf out flush redirects the standard
1109 pretty-printer output functions to the functions out and flush .
1110 The out function performs all the pretty-printer string output. It is
1112 called with a string s , a start position p , and a number of charac‐
1113 ters n ; it is supposed to output characters p to p + n - 1 of s .
1114 The flush function is called whenever the pretty-printer is flushed
1116 (via conversion %! , or pretty-printing indications @? or @. , or
1117 using low level functions print_flush or print_newline ).
1118 val pp_get_formatter_output_functions : formatter -> unit -> (string ->
1122 int -> int -> unit) * (unit -> unit)
1123 val get_formatter_output_functions : unit -> (string -> int -> int ->
1128 unit) * (unit -> unit)
1129 Return the current output functions of the standard pretty-printer.
1131 Redefining formatter output
1136 The Format module is versatile enough to let you completely redefine
1137 the meaning of pretty-printing output: you may provide your own func‐
1138 tions to define how to handle indentation, line splitting, and even
1139 printing of all the characters that have to be printed!
1140 Redefining output functions
1142 type formatter_out_functions = {
1143 out_string : string -> int -> int -> unit ;
1144 out_flush : unit -> unit ;
1145 out_newline : unit -> unit ;
1146 out_spaces : int -> unit ;
1147 out_indent : int -> unit ; (* .B "Since" 4.06.0
1148 *)
1149 }
1150 The set of output functions specific to a formatter:
1153 -the out_string function performs all the pretty-printer string output.
1155 It is called with a string s , a start position p , and a number of
1156 characters n ; it is supposed to output characters p to p + n - 1 of s
1157 .
1158 -the out_flush function flushes the pretty-printer output device.
1160 - out_newline is called to open a new line when the pretty-printer
1162 splits the line.
1163 -the out_spaces function outputs spaces when a break hint leads to spa‐
1165 ces instead of a line split. It is called with the number of spaces to
1166 output.
1167 -the out_indent function performs new line indentation when the
1169 pretty-printer splits the line. It is called with the indentation value
1170 of the new line.
1171 By default:
1173 -fields out_string and out_flush are output device specific; (e.g.
1175 output_string and flush for a out_channel device, or Buffer.add_sub‐
1176 string and ignore for a Buffer.t output device),
1177 -field out_newline is equivalent to out_string "\n" 0 1 ;
1179 -fields out_spaces and out_indent are equivalent to out_string
1181 (String.make n ' ') 0 n .
1182 Since 4.01.0
1186 val pp_set_formatter_out_functions : formatter -> formatter_out_func‐
1190 tions -> unit
1191 val set_formatter_out_functions : formatter_out_functions -> unit
1196 pp_set_formatter_out_functions ppf out_funs Set all the pretty-printer
1199 output functions of ppf to those of argument out_funs ,
1200 This way, you can change the meaning of indentation (which can be some‐
1202 thing else than just printing space characters) and the meaning of new
1203 lines opening (which can be connected to any other action needed by the
1204 application at hand).
1205 Reasonable defaults for functions out_spaces and out_newline are re‐
1207 spectively out_funs.out_string (String.make n ' ') 0 n and
1208 out_funs.out_string "\n" 0 1 .
1209 Since 4.01.0
1212 val pp_get_formatter_out_functions : formatter -> unit -> format‐
1216 ter_out_functions
1217 val get_formatter_out_functions : unit -> formatter_out_functions
1222 Return the current output functions of the pretty-printer, including
1224 line splitting and indentation functions. Useful to record the current
1225 setting and restore it afterwards.
1226 Since 4.01.0
1229 Redefining semantic tag operations
1234 type formatter_stag_functions = {
1235 mark_open_stag : stag -> string ;
1236 mark_close_stag : stag -> string ;
1237 print_open_stag : stag -> unit ;
1238 print_close_stag : stag -> unit ;
1239 }
1240 The semantic tag handling functions specific to a formatter: mark ver‐
1243 sions are the 'tag-marking' functions that associate a string marker to
1244 a tag in order for the pretty-printing engine to write those markers as
1245 0 length tokens in the output device of the formatter. print versions
1246 are the 'tag-printing' functions that can perform regular printing when
1247 a tag is closed or opened.
1248 Since 4.08.0
1251 val pp_set_formatter_stag_functions : formatter -> formatter_stag_func‐
1255 tions -> unit
1256 val set_formatter_stag_functions : formatter_stag_functions -> unit
1261 pp_set_formatter_stag_functions ppf tag_funs changes the meaning of
1264 opening and closing semantic tag operations to use the functions in
1265 tag_funs when printing on ppf .
1266 When opening a semantic tag with name t , the string t is passed to the
1268 opening tag-marking function (the mark_open_stag field of the record
1269 tag_funs ), that must return the opening tag marker for that name. When
1270 the next call to close_stag () happens, the semantic tag name t is sent
1271 back to the closing tag-marking function (the mark_close_stag field of
1272 record tag_funs ), that must return a closing tag marker for that name.
1273 The print_ field of the record contains the tag-printing functions that
1275 are called at tag opening and tag closing time, to output regular mate‐
1276 rial in the pretty-printer queue.
1277 Since 4.08.0
1280 val pp_get_formatter_stag_functions : formatter -> unit -> format‐
1284 ter_stag_functions
1285 val get_formatter_stag_functions : unit -> formatter_stag_functions
1290 Return the current semantic tag operation functions of the standard
1292 pretty-printer.
1293 Since 4.08.0
1296 Defining formatters
1301 Defining new formatters permits unrelated output of material in paral‐
1302 lel on several output devices. All the parameters of a formatter are
1303 local to the formatter: right margin, maximum indentation limit, maxi‐
1304 mum number of pretty-printing boxes simultaneously open, ellipsis, and
1305 so on, are specific to each formatter and may be fixed independently.
1306 For instance, given a Buffer.t buffer b , Format.formatter_of_buffer b
1308 returns a new formatter using buffer b as its output device. Simi‐
1309 larly, given a out_channel output channel oc , Format.format‐
1310 ter_of_out_channel oc returns a new formatter using channel oc as its
1311 output device.
1312 Alternatively, given out_funs , a complete set of output functions for
1314 a formatter, then Format.formatter_of_out_functions out_funs computes a
1315 new formatter using those functions for output.
1316 val formatter_of_out_channel : out_channel -> formatter
1318 formatter_of_out_channel oc returns a new formatter writing to the cor‐
1321 responding output channel oc .
1322 val std_formatter : formatter
1326 The standard formatter to write to standard output.
1328 It is defined as Format.formatter_of_out_channel stdout .
1330 val err_formatter : formatter
1334 A formatter to write to standard error.
1336 It is defined as Format.formatter_of_out_channel stderr .
1338 val formatter_of_buffer : Buffer.t -> formatter
1342 formatter_of_buffer b returns a new formatter writing to buffer b . At
1345 the end of pretty-printing, the formatter must be flushed using For‐
1346 mat.pp_print_flush or Format.pp_print_newline , to print all the pend‐
1347 ing material into the buffer.
1348 val stdbuf : Buffer.t
1352 The string buffer in which str_formatter writes.
1354 val str_formatter : formatter
1358 A formatter to output to the Format.stdbuf string buffer.
1360 str_formatter is defined as Format.formatter_of_buffer Format.stdbuf .
1363 val flush_str_formatter : unit -> string
1367 Returns the material printed with str_formatter , flushes the formatter
1369 and resets the corresponding buffer.
1370 val make_formatter : (string -> int -> int -> unit) -> (unit -> unit)
1374 -> formatter
1375 make_formatter out flush returns a new formatter that outputs with
1378 function out , and flushes with function flush .
1379 For instance,
1381 make_formatter
1382 (Stdlib.output oc)
1383 (fun () -> Stdlib.flush oc)
1384 returns a formatter to the out_channel oc .
1385 val formatter_of_out_functions : formatter_out_functions -> formatter
1389 formatter_of_out_functions out_funs returns a new formatter that writes
1392 with the set of output functions out_funs .
1393 See definition of type Format.formatter_out_functions for the meaning
1395 of argument out_funs .
1396 Since 4.06.0
1399 Symbolic pretty-printing
1404 Symbolic pretty-printing is pretty-printing using a symbolic formatter,
1405 i.e. a formatter that outputs symbolic pretty-printing items.
1406 When using a symbolic formatter, all regular pretty-printing activities
1408 occur but output material is symbolic and stored in a buffer of output
1409 items. At the end of pretty-printing, flushing the output buffer al‐
1410 lows post-processing of symbolic output before performing low level
1411 output operations.
1412 In practice, first define a symbolic output buffer b using:
1414 - let sob = make_symbolic_output_buffer () . Then define a symbolic
1416 formatter with:
1417 - let ppf = formatter_of_symbolic_output_buffer sob
1419 Use symbolic formatter ppf as usual, and retrieve symbolic items at end
1421 of pretty-printing by flushing symbolic output buffer sob with:
1422 - flush_symbolic_output_buffer sob .
1424 type symbolic_output_item =
1427 | Output_flush (* symbolic flush command
1428 *)
1429 | Output_newline (* symbolic newline command
1430 *)
1431 | Output_string of string
1432 (* Output_string s : symbolic output for string s
1433 *)
1435 | Output_spaces of int
1436 (* Output_spaces n : symbolic command to output n spaces
1437 *)
1438 | Output_indent of int
1439 (* Output_indent i : symbolic indentation of size i
1440 *)
1442 Items produced by symbolic pretty-printers
1445 Since 4.06.0
1448 type symbolic_output_buffer
1451 The output buffer of a symbolic pretty-printer.
1454 Since 4.06.0
1457 val make_symbolic_output_buffer : unit -> symbolic_output_buffer
1461 make_symbolic_output_buffer () returns a fresh buffer for symbolic out‐
1464 put.
1465 Since 4.06.0
1468 val clear_symbolic_output_buffer : symbolic_output_buffer -> unit
1472 clear_symbolic_output_buffer sob resets buffer sob .
1475 Since 4.06.0
1478 val get_symbolic_output_buffer : symbolic_output_buffer -> sym‐
1482 bolic_output_item list
1483 get_symbolic_output_buffer sob returns the contents of buffer sob .
1486 Since 4.06.0
1489 val flush_symbolic_output_buffer : symbolic_output_buffer -> sym‐
1493 bolic_output_item list
1494 flush_symbolic_output_buffer sob returns the contents of buffer sob and
1497 resets buffer sob . flush_symbolic_output_buffer sob is equivalent to
1498 let items = get_symbolic_output_buffer sob in
1499 clear_symbolic_output_buffer sob; items
1500 Since 4.06.0
1504 val add_symbolic_output_item : symbolic_output_buffer -> symbolic_out‐
1508 put_item -> unit
1509 add_symbolic_output_item sob itm adds item itm to buffer sob .
1512 Since 4.06.0
1515 val formatter_of_symbolic_output_buffer : symbolic_output_buffer ->
1519 formatter
1520 formatter_of_symbolic_output_buffer sob returns a symbolic formatter
1523 that outputs to symbolic_output_buffer sob .
1524 Since 4.06.0
1527 Convenience formatting functions.
1532 val pp_print_list : ?pp_sep:(formatter -> unit -> unit) -> (formatter
1533 -> 'a -> unit) -> formatter -> 'a list -> unit
1534 pp_print_list ?pp_sep pp_v ppf l prints items of list l , using pp_v to
1537 print each item, and calling pp_sep between items ( pp_sep defaults to
1538 Format.pp_print_cut . Does nothing on empty lists.
1539 Since 4.02.0
1542 val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) -> (formatter ->
1546 'a -> unit) -> formatter -> 'a Seq.t -> unit
1547 pp_print_seq ?pp_sep pp_v ppf s prints items of sequence s , using pp_v
1550 to print each item, and calling pp_sep between items ( pp_sep defaults
1551 to Format.pp_print_cut . Does nothing on empty sequences.
1552 This function does not terminate on infinite sequences.
1554 Since 4.12
1557 val pp_print_text : formatter -> string -> unit
1561 pp_print_text ppf s prints s with spaces and newlines respectively
1564 printed using Format.pp_print_space and Format.pp_force_newline .
1565 Since 4.02.0
1568 val pp_print_option : ?none:(formatter -> unit -> unit) -> (formatter
1572 -> 'a -> unit) -> formatter -> 'a option -> unit
1573 pp_print_option ?none pp_v ppf o prints o on ppf using pp_v if o is
1576 Some v and none if it is None . none prints nothing by default.
1577 Since 4.08
1580 val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter
1584 -> 'e -> unit) -> formatter -> ('a, 'e) result -> unit
1585 pp_print_result ~ok ~error ppf r prints r on ppf using ok if r is Ok _
1588 and error if r is Error _ .
1589 Since 4.08
1592 val pp_print_either : left:(formatter -> 'a -> unit) -> right:(format‐
1596 ter -> 'b -> unit) -> formatter -> ('a, 'b) Either.t -> unit
1597 pp_print_either ~left ~right ppf e prints e on ppf using left if e is
1600 Either.Left _ and right if e is Either.Right _ .
1601 Since 4.13
1604 Formatted pretty-printing
1609 Module Format provides a complete set of printf like functions for
1610 pretty-printing using format string specifications.
1611 Specific annotations may be added in the format strings to give
1613 pretty-printing commands to the pretty-printing engine.
1614 Those annotations are introduced in the format strings using the @
1616 character. For instance, @ means a space break, @, means a cut, @[
1617 opens a new box, and @] closes the last open box.
1618 val fprintf : formatter -> ('a, formatter, unit) format -> 'a
1620 fprintf ff fmt arg1 ... argN formats the arguments arg1 to argN accord‐
1626 ing to the format string fmt , and outputs the resulting string on the
1627 formatter ff .
1628 The format string fmt is a character string which contains three types
1630 of objects: plain characters and conversion specifications as specified
1631 in the Printf module, and pretty-printing indications specific to the
1632 Format module.
1633 The pretty-printing indication characters are introduced by a @ charac‐
1635 ter, and their meanings are:
1636 - @[ : open a pretty-printing box. The type and offset of the box may
1638 be optionally specified with the following syntax: the < character,
1639 followed by an optional box type indication, then an optional integer
1640 offset, and the closing > character. Pretty-printing box type is one
1641 of h , v , hv , b , or hov . ' h ' stands for an 'horizontal'
1642 pretty-printing box, ' v ' stands for a 'vertical' pretty-printing box,
1643 ' hv ' stands for an 'horizontal/vertical' pretty-printing box, ' b '
1644 stands for an 'horizontal-or-vertical' pretty-printing box demonstrat‐
1645 ing indentation, ' hov ' stands a simple 'horizontal-or-vertical'
1646 pretty-printing box. For instance, @[<hov 2> opens an 'horizon‐
1647 tal-or-vertical' pretty-printing box with indentation 2 as obtained
1648 with open_hovbox 2 . For more details about pretty-printing boxes, see
1649 the various box opening functions open_*box .
1650 - @] : close the most recently opened pretty-printing box.
1652 - @, : output a 'cut' break hint, as with print_cut () .
1654 - @ : output a 'space' break hint, as with print_space () .
1656 - @; : output a 'full' break hint as with print_break . The nspaces and
1658 offset parameters of the break hint may be optionally specified with
1659 the following syntax: the < character, followed by an integer nspaces
1660 value, then an integer offset , and a closing > character. If no pa‐
1661 rameters are provided, the good break defaults to a 'space' break hint.
1662 - @. : flush the pretty-printer and split the line, as with print_new‐
1664 line () .
1665 - @<n> : print the following item as if it were of length n . Hence,
1667 printf "@<0>%s" arg prints arg as a zero length string. If @<n> is not
1668 followed by a conversion specification, then the following character of
1669 the format is printed as if it were of length n .
1670 - @{ : open a semantic tag. The name of the tag may be optionally spec‐
1672 ified with the following syntax: the < character, followed by an op‐
1673 tional string specification, and the closing > character. The string
1674 specification is any character string that does not contain the closing
1675 character '>' . If omitted, the tag name defaults to the empty string.
1676 For more details about semantic tags, see the functions For‐
1677 mat.open_stag and Format.close_stag .
1678 - @} : close the most recently opened semantic tag.
1680 - @? : flush the pretty-printer as with print_flush () . This is
1682 equivalent to the conversion %! .
1683 - @\n : force a newline, as with force_newline () , not the normal way
1685 of pretty-printing, you should prefer using break hints inside a verti‐
1686 cal pretty-printing box.
1687 Note: To prevent the interpretation of a @ character as a pretty-print‐
1689 ing indication, escape it with a % character. Old quotation mode @@ is
1690 deprecated since it is not compatible with formatted input interpreta‐
1691 tion of character '@' .
1692 Example: printf "@[%s@ %d@]@." "x =" 1 is equivalent to open_box ();
1694 print_string "x ="; print_space ();
1695 print_int 1; close_box (); print_newline () . It prints x = 1
1696 within a pretty-printing 'horizontal-or-vertical' box.
1697 val printf : ('a, formatter, unit) format -> 'a
1699 Same as fprintf above, but output on std_formatter .
1701 val eprintf : ('a, formatter, unit) format -> 'a
1705 Same as fprintf above, but output on err_formatter .
1707 val sprintf : ('a, unit, string) format -> 'a
1711 Same as printf above, but instead of printing on a formatter, returns a
1713 string containing the result of formatting the arguments. Note that
1714 the pretty-printer queue is flushed at the end of each call to sprintf
1715 .
1716 In case of multiple and related calls to sprintf to output material on
1718 a single string, you should consider using fprintf with the predefined
1719 formatter str_formatter and call flush_str_formatter () to get the fi‐
1720 nal result.
1721 Alternatively, you can use Format.fprintf with a formatter writing to a
1723 buffer of your own: flushing the formatter and the buffer at the end of
1724 pretty-printing returns the desired string.
1725 val asprintf : ('a, formatter, unit, string) format4 -> 'a
1729 Same as printf above, but instead of printing on a formatter, returns a
1731 string containing the result of formatting the arguments. The type of
1732 asprintf is general enough to interact nicely with %a conversions.
1733 Since 4.01.0
1736 val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a
1740 Same as Format.fprintf , except the formatter is the last argument.
1742 dprintf "..." a b c is a function of type formatter -> unit which can
1743 be given to a format specifier %t .
1744 This can be used as a replacement for Format.asprintf to delay format‐
1746 ting decisions. Using the string returned by Format.asprintf in a for‐
1747 matting context forces formatting decisions to be taken in isolation,
1748 and the final string may be created prematurely. Format.dprintf allows
1749 delay of formatting decisions until the final formatting context is
1750 known. For example:
1751 let t = Format.dprintf "%i@ %i@ %i" 1 2 3 in
1752 ...
1753 Format.printf "@[<v>%t@]" t
1754 Since 4.08.0
1758 val ifprintf : formatter -> ('a, formatter, unit) format -> 'a
1762 Same as fprintf above, but does not print anything. Useful to ignore
1764 some material when conditionally printing.
1765 Since 3.10.0
1768 Formatted Pretty-Printing with continuations.
1773 val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit,
1775 'a) format4 -> 'b
1776 Same as fprintf above, but instead of returning immediately, passes the
1778 formatter to its first argument at the end of printing.
1779 val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a)
1783 format4 -> 'b
1784 Same as Format.dprintf above, but instead of returning immediately,
1786 passes the suspended printer to its first argument at the end of print‐
1787 ing.
1788 Since 4.08.0
1791 val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit,
1795 'a) format4 -> 'b
1796 Same as kfprintf above, but does not print anything. Useful to ignore
1798 some material when conditionally printing.
1799 Since 3.12.0
1802 val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
1806 Same as sprintf above, but instead of returning the string, passes it
1808 to the first argument.
1809 val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 ->
1813 'b
1814 Same as asprintf above, but instead of returning the string, passes it
1816 to the first argument.
1817 Since 4.03
1820 Deprecated
1825 val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a
1826 Deprecated. This function is error prone. Do not use it. This func‐
1828 tion is neither compositional nor incremental, since it flushes the
1829 pretty-printer queue at each call.
1830 If you need to print to some buffer b , you must first define a format‐
1832 ter writing to b , using let to_b = formatter_of_buffer b ; then use
1833 regular calls to Format.fprintf with formatter to_b .
1834 val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b
1838 Deprecated. An alias for ksprintf .
1840 val set_all_formatter_output_functions : out:(string -> int -> int ->
1844 unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int
1845 -> unit) -> unit
1846 Deprecated. Subsumed by set_formatter_out_functions .
1848 val get_all_formatter_output_functions : unit -> (string -> int -> int
1852 -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
1853 Deprecated. Subsumed by get_formatter_out_functions .
1855 val pp_set_all_formatter_output_functions : formatter -> out:(string ->
1859 int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit)
1860 -> spaces:(int -> unit) -> unit
1861 Deprecated. Subsumed by pp_set_formatter_out_functions .
1863 val pp_get_all_formatter_output_functions : formatter -> unit ->
1867 (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int
1868 -> unit)
1869 Deprecated. Subsumed by pp_get_formatter_out_functions .
1871 String tags
1876 val pp_open_tag : formatter -> tag -> unit
1877 Deprecated. Subsumed by Format.pp_open_stag .
1879 val open_tag : tag -> unit
1883 Deprecated. Subsumed by Format.open_stag .
1885 val pp_close_tag : formatter -> unit -> unit
1889 Deprecated. Subsumed by Format.pp_close_stag .
1891 val close_tag : unit -> unit
1895 Deprecated. Subsumed by Format.close_stag .
1897 type formatter_tag_functions = {
1900 mark_open_tag : tag -> string ;
1901 mark_close_tag : tag -> string ;
1902 print_open_tag : tag -> unit ;
1903 print_close_tag : tag -> unit ;
1904 }
1905 Deprecated. Subsumed by Format.formatter_stag_functions .
1908 val pp_set_formatter_tag_functions : formatter -> formatter_tag_func‐
1912 tions -> unit
1913 Deprecated. Subsumed by Format.pp_set_formatter_stag_functions .
1915 This function will erase non-string tag formatting functions.
1918 val set_formatter_tag_functions : formatter_tag_functions -> unit
1922 Deprecated. Subsumed by Format.set_formatter_stag_functions .
1924 val pp_get_formatter_tag_functions : formatter -> unit -> format‐
1928 ter_tag_functions
1929 Deprecated. Subsumed by Format.pp_get_formatter_stag_functions .
1931 val get_formatter_tag_functions : unit -> formatter_tag_functions
1935 Deprecated. Subsumed by Format.get_formatter_stag_functions .
1937OCamldoc 2022-02-04 Stdlib.Format(3)