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

module Format: sig .. end

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

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

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

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

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

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

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

Если несколько областей записывают в один и тот же канал вывода, используя предопределенные форматеры (полученные с помощью Format.get_std_formatter или Format.get_err_formatter), вывод из областей будет чередоваться в тех моментах, когда форматеры сбрасываются, например, с помощью Format.print_flush. Эта синхронизация не выполняется форматерами, полученными из Format.formatter_of_out_channel (в стандартных или других каналах вывода).

Введение

Этот модуль можно рассматривать как расширение функциональности 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 () выводит подсказку разрыва «обрезать»: красивому принтеру можно разбить строку в этом месте, в противном случае он ничего не выводит.

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 выводит подсказку разрыва «полный»: красивому принтеру можно разбить строку в этом месте, в противном случае он выводит 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, ""))

Since 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;`

}

Since 4.08

val check_geometry : geometry -> bool

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

Since 4.08

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 ничего не делает.

Since 4.08.0

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

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

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

Since 4.11.0

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

val pp_get_geometry : formatter -> unit -> geometry

val get_geometry : unit -> geometry

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

Since 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 устанавливает максимальное количество одновременно открытых блоков форматирования.

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

Ничего не происходит, если 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;`	`(*`	Since 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.

Since 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.

Since 4.01.0

val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions

val get_formatter_out_functions : unit -> formatter_out_functions

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

Since 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 — это функции «печати тегов», которые могут выполнять обычную печать при закрытии или открытии тега.

Since 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_ записи содержит функции печати тегов, которые вызываются при открытии и закрытии тега, чтобы выводить обычные данные в очереди красивого принтера.

Since 4.08.0

val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions

val get_formatter_stag_functions : unit -> formatter_stag_functions

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

Since 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 synchronized_formatter_of_out_channel : out_channel -> formatter Domain.DLS.key

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

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

Alert неустойчив.

val std_formatter : formatter

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

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

val get_std_formatter : unit -> formatter

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

Since 5.0

val err_formatter : formatter

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

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

val get_err_formatter : unit -> formatter

get_err_formatter () возвращает текущий форматировщик области, используемый для записи в стандартный вывод ошибок.

Since 5.0

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 get_stdbuf : unit -> Buffer.t

get_stdbuf () возвращает текущий строковый буфер домена, в который записывает текущий строковый форматировщик домена.

Since 5.0

val str_formatter : formatter

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

str_formatter определён как Format.formatter_of_buffer Format.stdbuf.

val get_str_formatter : unit -> formatter

Текущий форматировщик домена для вывода в строковый буфер текущего домена.

Since 5.0

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 make_synchronized_formatter : (string -> int -> int -> unit) ->       (unit -> unit) -> formatter Domain.DLS.key

make_synchronized_formatter out flush возвращает ключ к доменно-локальному состоянию, которое содержит доменно-локальный форматировщик, который выводит с помощью функции out, и сбрасывает с помощью функции flush.

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

Since 5.0
Alert unstable.

val formatter_of_out_functions : formatter_out_functions -> formatter

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

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

Since 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.
@]: закрывает последний открытый блок красивой печати.
@,: выводит подсказку разрыва 'обрыв', как с print_cut ().
@ : выводит подсказку разрыва 'пробел', как с 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 выше, но вывод в get_std_formatter ().

Определяется аналогично fun fmt -> fprintf (get_std_formatter ()) fmt, но откладывает вызов get_std_formatter до получения последнего аргумента, необходимого для format. При использовании с несколькими областями вывод из областей будет чередоваться в точках, где форматировщик очищается, например, с помощью Format.print_flush.

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

Аналогично fprintf выше, но вывод в get_err_formatter ().

Определяется аналогично fun fmt -> fprintf (get_err_formatter ()) fmt, но откладывает вызов get_err_formatter до получения последнего аргумента, необходимого для format. При использовании с несколькими областями вывод из областей будет чередоваться в точках, где форматировщик очищается, например, с помощью Format.print_flush.

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