Формат модуля

module Format: sig .. end

Красивая печать.

Этот модуль реализует функционал красивой печати для форматирования значений внутри 'ящиков красивой печати' и 'семантических тегов' в сочетании с набором функций, похожих на printf. Красивый принтер разбивает строки в указанных подсказках разбиения и отступает строки в соответствии со структурой ящика. Аналогично, семантические теги могут использоваться для отделения представления текста от его содержимого.

Эта система красивой печати реализована как наложение поверх абстрактных форматеров, которые предоставляют базовые функции вывода. Некоторые форматеры предопределены, в частности:

Format.std_formatter выводит в stdout
Format.err_formatter выводит в stderr

Большинство функций в модуле Format представлены в двух вариантах: краткий вариант, который работает с Format.std_formatter, и общий вариант, начинающийся с pp_, который принимает форматер в качестве первого аргумента.

Дополнительные форматеры можно создать с помощью Format.formatter_of_out_channel, Format.formatter_of_buffer, Format.formatter_of_symbolic_output_buffer или с помощью пользовательских форматеров.

Введение

Вы можете рассматривать этот модуль как расширение функционала printf для обеспечения автоматического разбиения строк. Добавление аннотаций красивой печати к обычным printf форматам строк предоставляет вам отступы и разрывы строк. Аннотации красивой печати описаны ниже в документации функции Format.fprintf.

Вы также можете использовать явное управление и функции печати ящиков красивой печати, предоставленные этим модулем. Этот стиль более базовый, но более подробный, чем компактные fprintf форматы строк.

Например, последовательность open_box 0; print_string "x ="; print_space (); print_int 1; close_box (); print_newline () , которая печатает x = 1 внутри ящика красивой печати, может быть сокращена до printf "@[%s@ %i@]@." "x =" 1, или даже короче printf "@[x =@ %i@]@." 1.

Практические рекомендации для случайных пользователей этой библиотеки:

используйте простые ящики красивой печати (полученные с помощью open_box 0);
используйте простые подсказки разбиения, полученные с помощью print_cut () , которая выводит простую подсказку разбиения, или с помощью print_space () , которая выводит пробел, указывающий на подсказку разбиения;
после открытия ящика красивой печати отобразите его содержимое с помощью основных функций печати (например, print_int и print_string);
после печати содержимого ящика красивой печати вызовите close_box () для закрытия ящика;
в конце красивой печати очистите красивую печать, чтобы отобразить все оставшееся содержимое, например, выполните print_newline ().

Поведение команд красивой печати не определено, если нет открытого ящика красивой печати. Каждый ящик, открытый одной из функций open_ ниже, должен быть закрыт с помощью close_box для правильного форматирования. В противном случае часть информации, напечатанной в ящиках, может не быть выведена или может быть отформатирована неправильно.

В случае интерактивного использования каждая фраза выполняется в начальном состоянии стандартного красивого принтера: после выполнения каждой фразы интерактивная система закрывает все открытые ящики красивой печати, очищает все ожидающие тексты и сбрасывает стандартный красивого принтер.

Предупреждение: смешивание вызовов функций красивой печати этого модуля с вызовами Stdlib функций вывода низкого уровня приводит к ошибкам.

Функции красивой печати выдают содержимое, которое откладывается в очереди красивого принтера и стеках, чтобы вычислить правильное разбиение строк. В отличие от этого, основные функции ввода-вывода записывают информацию непосредственно в устройство вывода. Вследствие этого, вывод базовой функции ввода-вывода может появиться до вывода функции красивой печати, которая была вызвана ранее. Например, Stdlib.print_string "<"; Format.print_string "PRETTY"; Stdlib.print_string ">"; Format.print_string "TEXT"; приводит к выводу <>PRETTYTEXT.

Формататоры

type formatter

Абстрактные данные, соответствующие красивому принтеру (также называемому форматером) и всему его механизму. См. также Определение форматеров.

Ящики красивой печати

Двигатель красивой печати использует понятия ящика красивой печати и подсказки разбиения для управления отступами и разбиением строк в красивом принтере.

Каждый тип ящика красивой печати вводит специфическую политику разбиения строк:

внутри горизонтального ящика подсказки разбиения никогда не разбивают строку (но строка может быть разделена в ящике, вложенном глубже),
внутри вертикального ящика подсказки разбиения всегда разбивают строку,
внутри горизонтально-вертикального ящика, если ящик помещается в текущей строке, то подсказки разбиения никогда не разбивают строку, в противном случае подсказка разбиения всегда разбивает строку,
внутри сжимающегося ящика подсказка разбиения никогда не разбивает строку, если только нет места в текущей строке.

Обратите внимание, что политика разбиения строк специфична для ящика: политика ящика не управляет политикой внутренних ящиков. Например, если вертикальный ящик вложен в горизонтальный ящик, все подсказки разбиения внутри вертикального ящика будут разбивать строку.

Кроме того, открытие ящика после максимального предела отступа разбивает строку, независимо от того, поместится ли ящик в строку.

val pp_open_box : formatter -> int -> unit

val open_box : int -> unit

pp_open_box ppf d открывает новый сжимающийся ящик красивой печати со смещением d в форматере ppf.

Внутри этого ящика красивого принтер печатает столько материала, сколько возможно, на каждой строке.

Подсказка разбиения разбивает строку, если нет больше места в строке для печати остатка ящика.

Внутри этого ящика красивого принтер выделяет структуру ящика: если структурный ящик не помещается полностью в простую строку, подсказка разбиения также разбивает строку, если разделение «перемещается влево» (т. е. новая строка получает отступ меньше, чем текущая строка).

Этот ящик является ящиком красивой печати общего назначения.

Если красивого принтер разбивает строку в ящике, к текущему отступу добавляется смещение d.

val pp_close_box : formatter -> unit -> unit

val close_box : unit -> unit

Закрывает наиболее недавно открытый ящик красивой печати.

val pp_open_hbox : formatter -> unit -> unit

val open_hbox : unit -> unit

pp_open_hbox ppf () открывает новый 'горизонтальный' ящик красивой печати.

Этот ящик печатает материал в одной строке.

Подсказки разбиения в горизонтальном ящике никогда не разбивают строку. (Разбиение строк все еще может происходить внутри вложенных ящиков).

val pp_open_vbox : formatter -> int -> unit

val open_vbox : int -> unit

pp_open_vbox ppf d открывает новый 'вертикальный' ящик красивой печати со смещением d.

Этот ящик печатает материал на столько строк, сколько подсказок разбиения в ящике.

Каждая подсказка разбиения в вертикальном ящике разбивает строку.

Если красивого принтер разбивает строку в ящике, к текущему отступу добавляется d.

val pp_open_hvbox : formatter -> int -> unit

val open_hvbox : int -> unit

pp_open_hvbox ppf d открывает новый ящик 'горизонтально-вертикальный' красивой печати со смещением d.

Этот ящик ведет себя как горизонтальный ящик, если он помещается в одной строке, в противном случае он ведет себя как вертикальный ящик.

Если красивого принтер разбивает строку в ящике, к текущему отступу добавляется d.

val pp_open_hovbox : formatter -> int -> unit

val open_hovbox : int -> unit

pp_open_hovbox ppf d открывает новый 'горизонтально-или-вертикальный' ящик красивой печати со смещением d.

Этот ящик печатает материал, насколько возможно, на каждой строке.

Подсказка разбиения разбивает строку, если нет больше места в строке для печати остатка ящика.

Если красивого принтер разбивает строку в ящике, к текущему отступу добавляется d.

Функции форматирования

val pp_print_string : formatter -> string -> unit

val print_string : string -> unit

pp_print_string ppf s печатает s в текущем ящике красивой печати.

val pp_print_bytes : formatter -> bytes -> unit

val print_bytes : bytes -> unit

pp_print_bytes ppf b печатает b в текущем ящике красивой печати.

Since 4.13.0

val pp_print_as : formatter -> int -> string -> unit

val print_as : int -> string -> unit

pp_print_as ppf len s печатает s в текущем ящике красивой печати. Красивый принтер форматирует s так, как будто его длина равна len.

val pp_print_int : formatter -> int -> unit

val print_int : int -> unit

Вывести целое число в текущем ящике красивой печати.

val pp_print_float : formatter -> float -> unit

val print_float : float -> unit

Вывести число с плавающей запятой в текущем ящике красивой печати.

val pp_print_char : formatter -> char -> unit

val print_char : char -> unit

Вывести символ в текущем ящике красивой печати.

val pp_print_bool : formatter -> bool -> unit

val print_bool : bool -> unit

Вывести логическое значение в текущем ящике красивой печати.

Подсказки разбиения

«Подсказка разбиения» сообщает красивому принтеру о необходимости вывода пробела или разбиения строки, в зависимости от того, какой способ более подходит для текущих правил разбиения строк красивого принтера.

Подсказки разбиения используются для разделения элементов печати и являются обязательными для правильного разбиения строк и отступа элементов красивым принтером.

Простые подсказки разбиения:

пробел: вывести пробел или разбить строку, если это уместно,
разделить: разбить строку, если это уместно.

Примечание: понятия пробела и разбиения строк абстрактны для движка красивой печати, поскольку эти понятия могут быть полностью переопределены программистом. Однако в стандартных настройках красивого принтера «вывод пробела» означает просто вывод символа пробела (код ASCII 32), а «разбить строку» означает вывод символа новой строки (код ASCII 10).

val pp_print_space : formatter -> unit -> unit

val print_space : unit -> unit

pp_print_space ppf () генерирует подсказку разбиения «пробел»: красивого принтер может разбить строку в этой точке, иначе он выводит один пробел.

pp_print_space ppf () эквивалентно pp_print_break ppf 1 0.

val pp_print_cut : formatter -> unit -> unit

val print_cut : unit -> unit

pp_print_cut ppf () выводит подсказку о разрыве строки «cut»: красивого печатающего устройства может разбить строку в этом месте, в противном случае он ничего не выводит.

pp_print_cut ppf () эквивалентно pp_print_break ppf 0 0.

val pp_print_break : formatter -> int -> int -> unit

val print_break : int -> int -> unit

pp_print_break ppf nspaces offset выводит подсказку о разрыве строки «full»: красивого печатающего устройства может разбить строку в этом месте, в противном случае он выводит nspaces пробелов.

Если красивое печатающее устройство разбивает строку, то offset добавляется к текущему отступу.

val pp_print_custom_break : formatter ->       fits:string * int * string -> breaks:string * int * string -> unit

pp_print_custom_break ppf ~fits:(s1, n, s2) ~breaks:(s3, m, s4) выводит пользовательскую подсказку о разрыве строки: красивое печатающее устройство может разбить строку в этом месте.

Если оно не разбивает строку, то оно выводит s1, затем n пробелов, затем s2.

Если оно разбивает строку, то оно выводит строку s3, затем отступ (в соответствии с правилами ячейки), затем смещение на m пробелов, затем строку s4.

Хотя n и m обрабатываются formatter_out_functions.out_indent, строки будут обрабатываться formatter_out_functions.out_string. Это позволяет настроить форматирование, которое обрабатывает отступы отдельно, например, выводит теги <br/> или сущности  .

Пользовательский разрыв полезен, если вы хотите изменить видимые (непробельные) символы, которые выводятся в случае разрыва или отсутствия разрыва. Например, при печати списка [a; b; c] , вы можете добавить заключительный символ «;» при вертикальной печати:

[
  a;
  b;
  c;
]

Вы можете сделать это следующим образом:

printf "@[<v 0>[@;<0 2>@[<v 0>a;@,b;@,c@]%t]@]@\n"
  (pp_print_custom_break ~fits:("", 0, "") ~breaks:(";", 0, ""))

С тех пор как 4.08.0

val pp_force_newline : formatter -> unit -> unit

val force_newline : unit -> unit

Вынужденная новая строка в текущей ячейке красивого форматирования.

Красивое печатающее устройство должно разбить строку в этом месте,

Не обычный способ красивого форматирования, так как принудительное разделение строк может повлиять на текущие счётчики строк и вычисления размеров ячейки. Использование подсказок о разрыве строк внутри окружающего вертикального блока является лучшей альтернативой.

val pp_print_if_newline : formatter -> unit -> unit

val print_if_newline : unit -> unit

Выполнить следующую команду форматирования, если предыдущая строка была только что разделена. В противном случае пропустить следующую команду форматирования.

Окончание красивого форматирования

val pp_print_flush : formatter -> unit -> unit

val print_flush : unit -> unit

Конец красивого форматирования: сбрасывает красивое печатающее устройство в начальное состояние.

Все открытые ячейки красивого форматирования закрываются, весь ожидающий текст печатается. Кроме того, буфер вывода красивого печатающего устройства сбрасывается, чтобы убедиться, что весь ожидающий текст действительно отображается.

Примечание: никогда не используйте print_flush в обычном процессе красивого форматирования, так как красивое печатающее устройство использует сложную систему буферизации для правильного выравнивания вывода; ручное сброс этих буферов в случайном порядке повлияет на стратегию красивого печатающего устройства и приведет к плохому отображению.

Рассмотрите использование print_flush только в случае, если обязательное отображение всего ожидаемого материала обязательно (например, в случае интерактивного использования, когда вы хотите, чтобы пользователь прочитал некоторый текст), и когда сброс состояния красивого печатающего устройства не повлияет на дальнейшее красивое форматирование.

Предупреждение: Если устройство вывода красивого печатающего устройства является каналом вывода, повторяющиеся вызовы print_flush означают повторяющиеся вызовы flush для сброса канала вывода; эти явные вызовы сброса могут нарушить стратегию буферизации каналов вывода и могут значительно повлиять на эффективность.

val pp_print_newline : formatter -> unit -> unit

val print_newline : unit -> unit

Конец красивого форматирования: сбрасывает красивое печатающее устройство в начальное состояние.

Все открытые ячейки красивого форматирования закрываются, весь ожидающий текст печатается.

Эквивалентно Format.print_flush за которым следует новая строка. Обратите внимание на соответствующие предупреждения для Format.print_flush.

Примечание: это не обычный способ вывода новой строки; предпочтительный метод — использование подсказок о разрыве строк внутри вертикальной ячейки красивого форматирования.

Отступ

val pp_set_margin : formatter -> int -> unit

val set_margin : int -> unit

pp_set_margin ppf d устанавливает правый отступ до d (в символах): красивое печатающее устройство разбивает строки, которые выходят за пределы правого отступа, в соответствии с подсказками о разрыве строк. Установка отступа до d означает, что движок форматирования стремится напечатать не более d-1 символов в строке. Ничего не происходит, если d меньше 2. Если d слишком велико, правый отступ устанавливается на максимальное допустимое значение (которое больше 10 ^ 9). Если d меньше текущего максимального предела отступа, максимальный предел отступа уменьшается, пытаясь сохранить минимальное соотношение max_indent/margin>=50% и при необходимости текущую разницу margin - max_indent.

См. также Format.pp_set_geometry.

val pp_get_margin : formatter -> unit -> int

val get_margin : unit -> int

Возвращает позицию правого отступа.

Максимальный предел отступа

val pp_set_max_indent : formatter -> int -> unit

val set_max_indent : int -> unit

pp_set_max_indent ppf d устанавливает максимальный предел отступа строк до d (в символах): как только этот предел достигается, новые ячейки красивого форматирования отклоняются влево, если только заключительная ячейка полностью не помещается в текущей строке. В качестве иллюстрации,

 set_margin 10; set_max_indent 5; printf "@[123456@[7@]89A@]@."

дает

    123456
    789A

потому что вложенная ячейка "@[7@]" открыта после достижения максимального предела отступа (7>5) и её родительская ячейка не помещается в текущей строке. Либо уменьшить длину родительской ячейки, чтобы она поместилась в строку:

 printf "@[123456@[7@]89@]@."

или открыть промежуточную ячейку до достижения максимального предела отступа, которая помещается в текущей строке

 printf "@[123@[456@[7@]89@]A@]@."

избегает отклонения вложенных ячеек влево и выводит соответственно "123456789" и "123456789A" . Также обратите внимание, что вертикальные ячейки никогда не помещаются в строку, а горизонтальные ячейки всегда полностью помещаются в текущей строке. Открытие ячейки может разбить строку, даже если её содержимое может поместиться. Если это поведение проблематично, его можно ограничить, установив максимальный предел отступа до margin - 1. Обратите внимание, что установка максимального предела отступа до margin недопустима.

Ничего не происходит, если d меньше 2.

Если d слишком велико, предел устанавливается на максимальное допустимое значение (которое больше 10 ^ 9).

Если d больше или равен текущему отступу, он игнорируется, и текущий максимальный предел отступа сохраняется.

См. также Format.pp_set_geometry.

val pp_get_max_indent : formatter -> unit -> int

val get_max_indent : unit -> int

Возвращает максимальный предел отступа (в символах).

Геометрия

Функции геометрии могут быть использованы для одновременного управления связанными переменными, отступом и максимальным пределом отступа.

type geometry = {

	`max_indent : int;`
	`margin : int;`

}

val check_geometry : geometry -> bool

Проверить, является ли геометрия форматирования допустимой: 1 < max_indent < margin

val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit

val set_geometry : max_indent:int -> margin:int -> unit

val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit

val safe_set_geometry : max_indent:int -> margin:int -> unit

pp_set_geometry ppf ~max_indent ~margin устанавливает как отступ, так и максимальный предел отступа для ppf.

Когда 1 < max_indent < margin, pp_set_geometry ppf ~max_indent ~margin эквивалентно pp_set_margin ppf margin; pp_set_max_indent ppf max_indent; и избегает тонкой ошибки pp_set_max_indent ppf max_indent; pp_set_margin ppf margin;

За пределами этого диапазона pp_set_geometry вызывает исключение недопустимого аргумента, в то время как pp_safe_set_geometry ничего не делает.

С тех пор как 4.08.0

val pp_update_geometry : formatter -> (geometry -> geometry) -> unit

pp_update_geometry ppf (fun geo -> { geo with ... }) позволяет обновлять геометрию форматировщика таким образом, чтобы она была устойчива к расширению записи geometry новыми полями.

Вызывает исключение недопустимого аргумента, если возвращаемая геометрия не удовлетворяет Format.check_geometry.

С тех пор как 4.11.0

val update_geometry : (geometry -> geometry) -> unit

val pp_get_geometry : formatter -> unit -> geometry

val get_geometry : unit -> geometry

Возвращает текущую геометрию форматировщика

С тех пор как 4.08.0

Максимальная глубина форматирования

Максимальная глубина форматирования — это максимальное количество одновременно открытых ячеек красивого форматирования.

Материал внутри ячеек, вложенных глубже, печатается как многоточие (точнее, как текст, возвращаемый Format.get_ellipsis_text ()).

val pp_set_max_boxes : formatter -> int -> unit

val set_max_boxes : int -> unit

pp_set_max_boxes ppf max устанавливает максимальное количество одновременно открытых ячеек красивого форматирования.

Ничего не происходит, если max меньше 2.

val pp_get_max_boxes : formatter -> unit -> int

val get_max_boxes : unit -> int

Возвращает максимальное количество ячеек красивого форматирования, разрешённых до многоточия.

val pp_over_max_boxes : formatter -> unit -> bool

val over_max_boxes : unit -> bool

Проверяет, были ли уже открыты максимальное количество ячеек красивого форматирования.

Ячейки табуляции

Ячейка табуляции печатает материал на строках, разделённых на ячейки фиксированной длины. Ячейка табуляции предоставляет простой способ отображения вертикальных столбцов выровненного слева текста.

Эта ячейка имеет команду set_tab для определения границ ячеек и команду print_tab для перехода от ячейки к ячейке и разделения строки, когда больше нет ячеек для печати в строке.

Примечание: печать внутри табличной области осуществляется построчно, поэтому произвольное разделение строк внутри табличной области приводит к плохому отображению. Тем не менее, контролируемое использование табличных областей позволяет просто печатать столбцы внутри модуля Format.

val pp_open_tbox : formatter -> unit -> unit

val open_tbox : unit -> unit

open_tbox () открывает новую табличную область.

Эта область печатает строки, разделенные на ячейки фиксированной ширины.

Внутри табличной области специальные маркеры табуляции определяют точки интереса на строке (например, для разграничения границ ячеек). Функция Format.set_tab устанавливает маркер табуляции в точке вставки.

Табличная область имеет особые разрывы табуляции для перехода к следующему маркера табуляции или разделения строки. Функция Format.print_tbreak печатает разрыв табуляции.

val pp_close_tbox : formatter -> unit -> unit

val close_tbox : unit -> unit

Закрывает недавно открытую табличную область.

val pp_set_tab : formatter -> unit -> unit

val set_tab : unit -> unit

Устанавливает маркер табуляции в текущей точке вставки.

val pp_print_tab : formatter -> unit -> unit

val print_tab : unit -> unit

print_tab () выводит подсказку о разрыве табуляции "следующий": если он еще не установлен на маркера табуляции, точка вставки перемещается к первому маркера табуляции справа, или форматировщик разбивает строку, и точка вставки перемещается к самому левому маркера табуляции.

Это эквивалентно print_tbreak 0 0.

val pp_print_tbreak : formatter -> int -> int -> unit

val print_tbreak : int -> int -> unit

print_tbreak nspaces offset выводит подсказку о разрыве табуляции "полный".

Если он еще не установлен на маркера табуляции, точка вставки перемещается к первому маркера табуляции справа, и форматировщик печатает nspaces пробелов.

Если справа нет следующего маркера табуляции, форматировщик разбивает строку в этой точке, а затем точка вставки перемещается к самому левому маркера табуляции области.

Если форматировщик разбивает строку, к текущей отступу добавляется offset.

Эллипс

val pp_set_ellipsis_text : formatter -> string -> unit

val set_ellipsis_text : string -> unit

Установите текст эллипса, печатаемого, когда открыто слишком много блоков форматирования (по умолчанию одна точка, .).

val pp_get_ellipsis_text : formatter -> unit -> string

val get_ellipsis_text : unit -> string

Возвращает текст эллипса.

Семантические теги

type stag = ..

Семантические теги (или просто теги) — это определенные пользователем аннотации для ассоциации определенных операций пользователя с напечатанными сущностями.

Общее использование семантических тегов — это декорация текста для получения специфичного отображения шрифта или размера текста для устройства отображения или пометка разграничения сущностей (например, элементов HTML или TeX или управляющих последовательностей терминала). Более сложные методы использования семантических тегов могут обрабатывать динамическое изменение поведения форматировщика для правильной печати материала внутри некоторых конкретных тегов. Например, мы можем определить тег RGB следующим образом:

type stag += RGB of {r:int;g:int;b:int}

Для правильного разграничения напечатанных сущностей семантический тег должен открываться перед сущностью и закрываться после неё. Семантические теги должны быть правильно вложены, как скобки, используя Format.pp_open_stag и Format.pp_close_stag.

Операции, специфичные для тега, происходят всякий раз, когда открывается или закрывается тег. При каждом случае выполняются два вида операций: пометка тега и печать тега:

Операция пометки тега — это более простая операция, специфичная для тега: она просто записывает строку, специфичную для тега, в устройство вывода форматировщика. Пометка тега не вмешивается в вычисления разбиения строк.
Операция печати тега — это более сложная операция, специфичная для тега: она может печатать произвольный материал в форматировщике. Печать тега тесно связана с текущими операциями форматировщика.

Грубо говоря, пометка тега обычно используется для улучшения отображения текста на устройстве отображения, а печать тега позволяет точно настроить процедуры печати, чтобы напечатать одну и ту же сущность по-разному в зависимости от семантических тегов (например, напечатать дополнительный материал или даже пропустить части вывода).

Более точно: когда открывается или закрывается семантический тег, происходят как сами операции, так и последующие операции «печати тега» и «пометки тега»:

Печать семантического тега означает вызов функции форматировщика, специфичной для тега, print_open_stag (соответственно, print_close_stag ) со значением имени тега в качестве аргумента: эта функция печати тега может затем напечатать любой обычный материал в форматировщике (так что этот материал будет помещен в очередь форматировщика для дальнейших вычислений разбиения строк).
Пометка семантического тега означает вызов функции форматировщика, специфичной для тега, mark_open_stag (соответственно, mark_close_stag ) со значением имени тега в качестве аргумента: эта функция пометки тега может затем вернуть «открывающий маркер тега» (соответственно, «закрывающий маркер тега») для непосредственного вывода в устройство вывода форматировщика.

Написанные непосредственно в устройство вывода форматировщика, строки маркеров семантических тегов не считаются частью печатного материала, управляющего разбиением строк (другими словами, длина строк, соответствующих маркерам тегов, считается равной нулю для разбиения строк).

Таким образом, обработка семантических тегов в некотором смысле прозрачна для форматирования и не мешает обычному отступу. Следовательно, одна процедура форматирования может выводить как простой «verbatim» материал, так и более богатый отформатированный вывод в зависимости от обработки тегов. По умолчанию теги не активны, следовательно, вывод не оформлен информацией о тегах. Как только set_tags устанавливается в true, механизм форматирования учитывает теги и соответственно оформляет вывод.

Функции пометки тегов по умолчанию ведут себя как в HTML: строчные теги заключены в «<» и «>», а другие теги игнорируются; следовательно, открывающий маркер для строчного тега "t" — "<t>", а закрывающий маркер — "</t>".

Функции печати тегов по умолчанию ничего не делают.

Функции пометки и печати тегов настраиваются пользователем и могут быть установлены с помощью вызова Format.set_formatter_stag_functions.

Семантические операции с тегами могут быть включены или выключены с помощью Format.set_tags. Операции пометки тегов могут быть включены или выключены с помощью Format.set_mark_tags. Операции печати тегов могут быть включены или выключены с помощью Format.set_print_tags.

Since 4.08.0

type tag = string

type stag +=

|

String_tag of tag

(*

String_tag s — это строчный тег s. Строчные теги можно вставить либо явно с помощью конструктора String_tag, либо с помощью специального синтаксиса форматирования "@{<s> ... @}".

Since 4.08.0

*)

val pp_open_stag : formatter -> stag -> unit

val open_stag : stag -> unit

pp_open_stag ppf t открывает семантический тег с именем t.

Функция форматировщика print_open_stag по печати тегов вызывается с t в качестве аргумента; затем открывающий маркер тега для t, как задано mark_open_stag t, записывается в устройство вывода форматировщика.

Since 4.08.0

val pp_close_stag : formatter -> unit -> unit

val close_stag : unit -> unit

pp_close_stag ppf () закрывает последний открытый семантический тег t.

Закрывающий маркер, как задано mark_close_stag t, записывается в устройство вывода форматировщика; затем функция форматировщика print_close_stag по печати тегов вызывается с t в качестве аргумента.

Since 4.08.0

val pp_set_tags : formatter -> bool -> unit

val set_tags : bool -> unit

pp_set_tags ppf b включает или выключает обработку семантических тегов (по умолчанию выключено).

val pp_set_print_tags : formatter -> bool -> unit

val set_print_tags : bool -> unit

pp_set_print_tags ppf b включает или выключает операции печати тегов.

val pp_set_mark_tags : formatter -> bool -> unit

val set_mark_tags : bool -> unit

pp_set_mark_tags ppf b включает или выключает операции пометки тегов.

val pp_get_print_tags : formatter -> unit -> bool

val get_print_tags : unit -> bool

Возвращает текущий статус операций печати тегов.

val pp_get_mark_tags : formatter -> unit -> bool

val get_mark_tags : unit -> bool

Возвращает текущий статус операций пометки тегов.

val pp_set_formatter_out_channel : formatter -> out_channel -> unit

Перенаправление стандартного вывода форматировщика

val set_formatter_out_channel : out_channel -> unit

Перенаправить стандартный вывод форматировщика в указанный канал. (Все функции вывода стандартного форматировщика устанавливаются в функции вывода по умолчанию, печатающие в данный канал.)

set_formatter_out_channel эквивалентно Format.pp_set_formatter_out_channel std_formatter.

val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit

val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit

pp_set_formatter_output_functions ppf out flush перенаправляет стандартные функции вывода форматировщика на функции out и flush.

Функция out выполняет весь вывод строки форматировщика. Она вызывается со строкой s, начальной позицией p и количеством символов n; она должна вывести символы p по p + n - 1 из s.

Функция flush вызывается всякий раз, когда форматировщик сбрасывается (через преобразование %!, или указания форматирования @? или @., или с использованием функций низкого уровня print_flush или print_newline).

val pp_get_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit)

val get_formatter_output_functions : unit -> (string -> int -> int -> unit) * (unit -> unit)

Возвращает текущие функции вывода стандартного красивого принтера.

Переопределение вывода форматировщика

Модуль Format достаточно универсален, чтобы позволить вам полностью переопределить значение вывода красивой печати: вы можете предоставить свои собственные функции для определения того, как обрабатывать отступы, разделение строк и даже печать всех символов, которые должны быть напечатаны!

Переопределение функций вывода

type formatter_out_functions = {

`out_string : string -> int -> int -> unit;`
`out_flush : unit -> unit;`
`out_newline : unit -> unit;`
`out_spaces : int -> unit;`
`out_indent : int -> unit;`	`(*`	С момента 4.06.0	`*)`

}

Набор функций вывода, специфичных для форматировщика:

функция out_string выполняет весь вывод строки красивого принтера. Она вызывается со строкой s, начальной позицией p и количеством символов n; она должна выводить символы p до p + n - 1 из s.
функция out_flush сбрасывает буфер вывода красивого принтера.
out_newline вызывается для открытия новой строки, когда красивым принтер разделяет строку.
функция out_spaces выводит пробелы, когда подсказка перевода приводит к пробелам вместо разделения строк. Она вызывается с числом пробелов для вывода.
функция out_indent выполняет отступ новой строки, когда красивым принтер разделяет строку. Она вызывается со значением отступа новой строки.

По умолчанию:

поля out_string и out_flush зависят от устройства вывода; (например, output_string и flush для устройства out_channel, или Buffer.add_substring и ignore для устройства вывода Buffer.t),
поле out_newline эквивалентно out_string "\n" 0 1;
поля out_spaces и out_indent эквивалентны out_string (String.make n ' ') 0 n.

С момента 4.01.0

val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit

val set_formatter_out_functions : formatter_out_functions -> unit

pp_set_formatter_out_functions ppf out_funs Устанавливает все функции вывода красивого принтера ppf в те, которые заданы аргументом out_funs,

Таким образом, вы можете изменить значение отступов (что может быть чем-то другим, чем просто печать символов пробела) и значение открытия новых строк (что может быть связано с любым другим действием, необходимым текущему приложению).

Разумные значения по умолчанию для функций out_spaces и out_newline соответственно out_funs.out_string (String.make n ' ') 0 n и out_funs.out_string "\n" 0 1.

С момента 4.01.0

val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions

val get_formatter_out_functions : unit -> formatter_out_functions

Возвращает текущие функции вывода красивого принтера, включая функции разделения строк и отступов. Полезно для записи текущих настроек и последующего их восстановления.

С момента 4.01.0

Переопределение операций с тегами семантики

type formatter_stag_functions = {

	`mark_open_stag : stag -> string;`
	`mark_close_stag : stag -> string;`
	`print_open_stag : stag -> unit;`
	`print_close_stag : stag -> unit;`

}

Функции обработки тегов семантики, специфичные для форматировщика: версии mark — это функции «метки тегов», которые связывают строковый маркер с тегом, чтобы механизм красивой печати мог записать эти маркеры как токены длиной 0 в устройстве вывода форматировщика. Версии print — это функции «печати тегов», которые могут выполнять обычную печать при закрытии или открытии тега.

С момента 4.08.0

val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit

val set_formatter_stag_functions : formatter_stag_functions -> unit

pp_set_formatter_stag_functions ppf tag_funs изменяет смысл операций открытия и закрытия семантических тегов, используя функции в tag_funs при печати на ppf.

При открытии семантического тега с именем t, строка t передается функции маркировки открывающего тега (поле mark_open_stag записи tag_funs), которая должна вернуть маркер открывающего тега для этого имени. Когда происходит следующий вызов close_stag (), имя семантического тега t отправляется в функцию маркировки закрывающего тега (поле mark_close_stag записи tag_funs), которая должна вернуть маркер закрывающего тега для этого имени.

Поле print_ записи содержит функции печати тегов, которые вызываются во время открытия и закрытия тегов для вывода обычных данных в очереди красивого принтера.

С момента 4.08.0

val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions

val get_formatter_stag_functions : unit -> formatter_stag_functions

Возвращает текущие функции работы с семантическими тегами стандартного красивого принтера.

С момента 4.08.0

Определение форматировщиков

Определение новых форматировщиков позволяет параллельно выводить материал на нескольких устройствах вывода. Все параметры форматировщика локальны для форматировщика: правая граница, максимальный предел отступа, максимальное количество одновременно открытых блоков красивой печати, многоточие и так далее — специфичны для каждого форматировщика и могут быть установлены независимо.

Например, учитывая буфер Buffer.t b, Format.formatter_of_buffer b возвращает новый форматировщик, использующий буфер b в качестве устройства вывода. Аналогично, учитывая устройство вывода out_channel oc, Format.formatter_of_out_channel oc возвращает новый форматировщик, использующий канал oc в качестве устройства вывода.

В качестве альтернативы, учитывая out_funs, полный набор функций вывода для форматировщика, Format.formatter_of_out_functions out_funs вычисляет новый форматировщик, используя эти функции для вывода.

val formatter_of_out_channel : out_channel -> formatter

formatter_of_out_channel oc возвращает новый форматировщик, записывающий в соответствующий канал вывода oc.

val std_formatter : formatter

Стандартный форматировщик для записи в стандартный вывод.

Он определяется как Format.formatter_of_out_channel stdout.

val err_formatter : formatter

Форматировщик для записи в стандартный поток ошибок.

Он определяется как Format.formatter_of_out_channel stderr.

val formatter_of_buffer : Buffer.t -> formatter

formatter_of_buffer b возвращает новый форматировщик, записывающий в буфер b. По окончании красивой печати форматировщик должен быть сброшен с помощью Format.pp_print_flush или Format.pp_print_newline для печати всех ожидаемых данных в буфер.

val stdbuf : Buffer.t

Строковый буфер, в который str_formatter записывает.

val str_formatter : formatter

Форматировщик для вывода в строковый буфер Format.stdbuf.

str_formatter определяется как Format.formatter_of_buffer Format.stdbuf.

val flush_str_formatter : unit -> string

Возвращает данные, напечатанные с помощью str_formatter, сбрасывает форматировщик и сбрасывает соответствующий буфер.

val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter

make_formatter out flush возвращает новый форматировщик, который выводит с помощью функции out, и сбрасывает с помощью функции flush.

Например,

    make_formatter
      (Stdlib.output oc)
      (fun () -> Stdlib.flush oc)

возвращает форматировщик для out_channel oc.

val formatter_of_out_functions : formatter_out_functions -> formatter

formatter_of_out_functions out_funs возвращает новый форматировщик, который записывает с набором функций вывода out_funs.

См. определение типа Format.formatter_out_functions для значения аргумента out_funs.

С момента 4.06.0

Символьная красивую печать

Символьная красивая печать — это красивую печать, использующая символьный форматировщик, т. е. форматировщик, который выводит символьные элементы красивой печати.

При использовании символьного форматировщика все обычные операции красивой печати выполняются, но выходные данные являются символическими и хранятся в буфере элементов вывода. По окончании красивой печати сброс буфера вывода позволяет обработать символический вывод перед выполнением операций низкого уровня вывода.

На практике, сначала определите символьный буфер вывода b с помощью:

let sob = make_symbolic_output_buffer (). Затем определите символьный форматировщик с помощью:
let ppf = formatter_of_symbolic_output_buffer sob

Используйте символьный форматировщик ppf как обычно, и получите символьные элементы в конце форматирования, очистив буфер символьного вывода sob:

flush_symbolic_output_buffer sob.

type symbolic_output_item =

`\|`	`Output_flush`	`(*`	команда очистки символьного вывода	`*)`
`\|`	`Output_newline`	`(*`	команда символьного перевода строки	`*)`
`\|`	`Output_string of string`	`(*`	`Output_string s`: символьный вывод строки `s`	`*)`
`\|`	`Output_spaces of int`	`(*`	`Output_spaces n`: символьная команда вывода `n` пробелов	`*)`
`\|`	`Output_indent of int`	`(*`	`Output_indent i`: символьное отступа размера `i`	`*)`

Элементы, созданные символьными красивыми принтерами

Since 4.06.0

type symbolic_output_buffer

Буфер вывода символьного красивого принтера.

Since 4.06.0

val make_symbolic_output_buffer : unit -> symbolic_output_buffer

make_symbolic_output_buffer () возвращает новый буфер для символьного вывода.

Since 4.06.0

val clear_symbolic_output_buffer : symbolic_output_buffer -> unit

clear_symbolic_output_buffer sob сбрасывает буфер sob.

Since 4.06.0

val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list

get_symbolic_output_buffer sob возвращает содержимое буфера sob.

Since 4.06.0

val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list

flush_symbolic_output_buffer sob возвращает содержимое буфера sob и сбрасывает буфер sob. flush_symbolic_output_buffer sob эквивалентно let items = get_symbolic_output_buffer sob in clear_symbolic_output_buffer sob; items

Since 4.06.0

val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit

add_symbolic_output_item sob itm добавляет элемент itm в буфер sob.

Since 4.06.0

val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter

formatter_of_symbolic_output_buffer sob возвращает символьный форматировщик, выводимый в symbolic_output_buffer sob.

Since 4.06.0

Функции удобного форматирования.

val pp_print_list : ?pp_sep:(formatter -> unit -> unit) ->       (formatter -> 'a -> unit) -> formatter -> 'a list -> unit

pp_print_list ?pp_sep pp_v ppf l печатает элементы списка l, используя pp_v для печати каждого элемента и вызывая pp_sep между элементами (pp_sep по умолчанию Format.pp_print_cut. Ничего не делает для пустых списков.

Since 4.02.0

val pp_print_seq : ?pp_sep:(formatter -> unit -> unit) ->       (formatter -> 'a -> unit) ->       formatter -> 'a Seq.t -> unit

pp_print_seq ?pp_sep pp_v ppf s печатает элементы последовательности s, используя pp_v для печати каждого элемента и вызывая pp_sep между элементами (pp_sep по умолчанию Format.pp_print_cut. Ничего не делает для пустых последовательностей.

Эта функция не завершается для бесконечных последовательностей.

Since 4.12

val pp_print_text : formatter -> string -> unit

pp_print_text ppf s печатает s с пробелами и новыми строками соответственно, напечатанными с помощью Format.pp_print_space и Format.pp_force_newline.

Since 4.02.0

val pp_print_option : ?none:(formatter -> unit -> unit) ->       (formatter -> 'a -> unit) -> formatter -> 'a option -> unit

pp_print_option ?none pp_v ppf o печатает o на ppf используя pp_v если o равно Some v и none если это None. none ничего не печатает по умолчанию.

Since 4.08

val pp_print_result : ok:(formatter -> 'a -> unit) ->       error:(formatter -> 'e -> unit) ->       formatter -> ('a, 'e) result -> unit

pp_print_result ~ok ~error ppf r печатает r на ppf используя ok если r равно Ok _ и error если r равно Error _.

Since 4.08

val pp_print_either : left:(formatter -> 'a -> unit) ->       right:(formatter -> 'b -> unit) ->       formatter -> ('a, 'b) Either.t -> unit

pp_print_either ~left ~right ppf e печатает e на ppf используя left если e равно Either.Left _ и right если e равно Either.Right _.

Since 4.13

Форматированное красивое форматирование

Модуль Format предоставляет полный набор функций printf для красивого форматирования с использованием спецификаций формата строк.

В строках формата могут быть добавлены конкретные аннотации, чтобы дать команды красивого форматирования движку красивого форматирования.

Эти аннотации вводятся в строки формата с использованием символа @. Например, @ означает разрыв пробела, @, означает обрезку, @[ открывает новый блок, а @] закрывает последний открытый блок.

val fprintf : formatter -> ('a, formatter, unit) format -> 'a

fprintf ff fmt arg1 ... argN форматирует аргументы arg1 в argN в соответствии со строкой формата fmt, и выводит результирующую строку в форматировщике ff.

Строка формата fmt — это строка символов, которая содержит три типа объектов: обычные символы и спецификации преобразования, как указано в модуле Printf, и указания красивого форматирования, специфичные для модуля Format.

Символы указания красивого форматирования вводятся символом @ и их значения:

@[: открыть красивую область форматирования. Тип и смещение области могут быть необязательно указаны с помощью следующего синтаксиса: символ <, за которым следует необязательное указание типа области, затем необязательное целочисленное смещение и закрывающий символ >. Тип области красивого форматирования может быть одним из h, v, hv, b, или hov. 'h' означает область красивого форматирования «горизонтального» типа, 'v' означает область красивого форматирования «вертикального» типа, 'hv' означает область красивого форматирования «горизонтально-вертикального» типа, 'b' означает область красивого форматирования «горизонтально-или-вертикального» типа, демонстрирующую отступы, 'hov' означает простую область красивого форматирования «горизонтально-или-вертикального» типа. Например, @[<hov 2> открывает область красивого форматирования типа «горизонтально-или-вертикального» с отступом 2, как полученным с помощью open_hovbox 2. Для получения более подробной информации об областях красивого форматирования, см. различные функции открытия областей open_*box.
@]: закрыть последнюю открытую область красивого форматирования.
@,: вывести подсказку разрыва «cut», как в print_cut ().
print_space (): вывести подсказку разрыва «пробел», как в print_space ().
@;: вывести подсказку разрыва «полный», как в print_break. Параметры nspaces и offset подсказки разрыва могут быть необязательно указаны следующим синтаксисом: символ <, за которым следует целое значение nspaces, затем целое значение offset, и закрывающий символ > . Если параметры не указаны, значение подсказки разрыва по умолчанию — «пробел».
@.: очистить форматировщик красивого вывода и разбить строку, как в print_newline ().
@<n>: вывести следующий элемент так, как будто его длина равна n. Следовательно, printf "@<0>%s" arg выводит arg как строку длиной ноль. Если @<n> не последует спецификация преобразования, то следующий символ формата выводится, как будто его длина равна n.
@{: открыть семантический тег. Имя тега может быть необязательно указано следующим синтаксисом: символ <, за которым следует необязательное строковое указание, и закрывающий символ > . Строковое указание — любая строка символов, которая не содержит закрывающий символ '>'. Если указание опущено, имя тега по умолчанию — пустая строка. Для получения более подробной информации о семантических тегах, см. функции Format.open_stag и Format.close_stag.
@}: закрыть последний открытый семантический тег.
@?: очистить форматировщик красивого вывода, как в print_flush (). Это эквивалентно преобразованию %!.
@\n: принудительно перейти на новую строку, как в force_newline (), а не обычным способом красивого форматирования, вы должны предпочесть использовать подсказки разрыва внутри вертикальной области форматирования.

Примечание: Чтобы предотвратить интерпретацию символа @ как указания форматирования, экранируйте его символом %. Старый режим кавычек @@ устарел, так как он несовместим с интерпретацией форматированного ввода символа '@'.

Пример: printf "@[%s@ %d@]@." "x =" 1 эквивалентно open_box (); print_string "x ="; print_space (); print_int 1; close_box (); print_newline (). Он выводит x = 1 внутри области красивого форматирования типа «горизонтально-или-вертикального».

val printf : ('a, formatter, unit) format -> 'a

То же, что и fprintf выше, но вывод на std_formatter.

val eprintf : ('a, formatter, unit) format -> 'a

То же, что и fprintf выше, но вывод на err_formatter.

val sprintf : ('a, unit, string) format -> 'a

То же, что и printf выше, но вместо вывода на форматировщик возвращает строку, содержащую результат форматирования аргументов. Обратите внимание, что очередь форматировщика красивого вывода очищается в конце каждого вызова sprintf.

В случае нескольких и связанных вызовов sprintf для вывода материала в одной строке, вы должны рассмотреть использование fprintf с предопределенным форматировщиком str_formatter и вызов flush_str_formatter () для получения окончательного результата.

В качестве альтернативы вы можете использовать Format.fprintf с форматировщиком, записывающим в буфер, который вам принадлежит: очистка форматировщика и буфера в конце красивого форматирования возвращает желаемую строку.

val asprintf : ('a, formatter, unit, string) format4 -> 'a

То же, что и printf выше, но вместо вывода на форматировщик возвращает строку, содержащую результат форматирования аргументов. Тип asprintf достаточно общий, чтобы хорошо взаимодействовать с преобразованиями %a.

Since 4.01.0

val dprintf : ('a, formatter, unit, formatter -> unit) format4 -> 'a

То же, что и Format.fprintf, за исключением того, что форматировщик является последним аргументом. dprintf "..." a b c — это функция типа formatter -> unit, которую можно передать в спецификатор формата %t.

Это может использоваться как замена Format.asprintf для отсрочки принятия решений по форматированию. Использование строки, возвращаемой Format.asprintf, в контексте форматирования заставляет принимать решения по форматированию изолированно, и окончательная строка может быть создана преждевременно. Format.dprintf позволяет отложить принятие решений по форматированию до тех пор, пока не будет известен окончательный контекст форматирования. Например:

  let t = Format.dprintf "%i@ %i@ %i" 1 2 3 in
  ...
  Format.printf "@[<v>%t@]" t

Since 4.08.0

val ifprintf : formatter -> ('a, formatter, unit) format -> 'a

То же, что и fprintf выше, но ничего не печатает. Полезно игнорировать некоторый материал при условном выводе.

Since 3.10.0

Форматированный красивый вывод с продолжениями.

val kfprintf : (formatter -> 'a) ->       formatter -> ('b, formatter, unit, 'a) format4 -> 'b

То же, что и fprintf выше, но вместо немедленного возврата передает форматировщик своему первому аргументу в конце вывода.

val kdprintf : ((formatter -> unit) -> 'a) ->       ('b, formatter, unit, 'a) format4 -> 'b

То же, что и Format.dprintf выше, но вместо немедленного возврата передает приостановленный форматировщик своему первому аргументу в конце вывода.

Since 4.08.0

val ikfprintf : (formatter -> 'a) ->       formatter -> ('b, formatter, unit, 'a) format4 -> 'b

То же, что и kfprintf выше, но ничего не печатает. Полезно игнорировать некоторый материал при условном выводе.

Since 3.12.0

val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b

То же, что и sprintf выше, но вместо возврата строки передает её первому аргументу.

val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) format4 -> 'b

То же, что и asprintf выше, но вместо возврата строки передает её первому аргументу.

Since 4.03

Устаревшее

val bprintf : Buffer.t -> ('a, formatter, unit) format -> 'a

Устарело. Эта функция подвержена ошибкам. Не использовать. Эта функция не является композиционной и не является инкрементальной, поскольку очищает очередь форматировщика красивого вывода при каждом вызове. Если вам нужно выводить в какой-то буфер b, вы должны сначала определить форматировщик, записывающий в b, используя let to_b = formatter_of_buffer b; затем используйте обычные вызовы Format.fprintf с форматировщиком to_b.

val kprintf : (string -> 'a) -> ('b, unit, string, 'a) format4 -> 'b

Устарело. Псевдоним для ksprintf.

val set_all_formatter_output_functions : out:(string -> int -> int -> unit) ->       flush:(unit -> unit) ->       newline:(unit -> unit) -> spaces:(int -> unit) -> unit

Устарело. Заменено на set_formatter_out_functions.

val get_all_formatter_output_functions : unit ->       (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) *       (int -> unit)

Устарело. Заменено на get_formatter_out_functions.

val pp_set_all_formatter_output_functions : formatter ->       out:(string -> int -> int -> unit) ->       flush:(unit -> unit) ->       newline:(unit -> unit) -> spaces:(int -> unit) -> unit

Устарело. Заменено на pp_set_formatter_out_functions.

val pp_get_all_formatter_output_functions : formatter ->       unit ->       (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) *       (int -> unit)

Устарело. Заменено на pp_get_formatter_out_functions.

Строковые теги

val pp_open_tag : formatter -> tag -> unit

Устарело. Заменено на Format.pp_open_stag.

val open_tag : tag -> unit

Устарело. Заменено на Format.open_stag.

val pp_close_tag : formatter -> unit -> unit

Устарело. Заменено на Format.pp_close_stag.

val close_tag : unit -> unit

Устарело. Заменено на Format.close_stag.

type formatter_tag_functions = {

	`mark_open_tag : tag -> string;`
	`mark_close_tag : tag -> string;`
	`print_open_tag : tag -> unit;`
	`print_close_tag : tag -> unit;`

}

Устарело. Заменено на Format.formatter_stag_functions.

val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit

Устарело. Заменено на Format.pp_set_formatter_stag_functions.

Эта функция удалит функции форматирования тегов, не являющихся строками.

val set_formatter_tag_functions : formatter_tag_functions -> unit

Устарело. Заменено на Format.set_formatter_stag_functions.

val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions

Устарело. Заменено на Format.pp_get_formatter_stag_functions.

val get_formatter_tag_functions : unit -> formatter_tag_functions

Устарело. Заменено на Format.get_formatter_stag_functions.