Характеристики

break(binary()) :: doc_break()

Возвращает документ разрыва на основе заданного string.

Этот разрыв может быть отображён как перевод строки или как заданное string, в зависимости от mode выбранного макета.

Примеры

Давайте создадим документ, склеив две строки с разрывом между ними:

iex> doc = Inspect.Algebra.concat(["a", Inspect.Algebra.break("\t"), "b"])
iex> Inspect.Algebra.format(doc, 80)
["a", "\t", "b"]

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

iex> break = Inspect.Algebra.break("\t")
iex> doc = Inspect.Algebra.concat([String.duplicate("a", 20), break, "b"])
iex> doc = Inspect.Algebra.group(doc)
iex> Inspect.Algebra.format(doc, 10)
["aaaaaaaaaaaaaaaaaaaa", "\n", "b"]

Характеристики

collapse_lines(pos_integer()) :: doc_collapse()

Сжимает все новые строки и пробелы, следующие за этим узлом, вывода до max новых строк.

Характеристики

color(t(), Inspect.Opts.color_key(), Inspect.Opts.t()) :: doc_color()

Изменяет цвет документа, если color_key имеет цвет в параметрах.

Характеристики

concat([t()]) :: t()

Объединяет список документов, возвращая новый документ.

Примеры

iex> doc = Inspect.Algebra.concat(["a", "b", "c"])
iex> Inspect.Algebra.format(doc, 80)
["a", "b", "c"]

Характеристики

concat(t(), t()) :: t()

Объединяет два сущности документов, возвращая новый документ.

Примеры

iex> doc = Inspect.Algebra.concat("hello", "world")
iex> Inspect.Algebra.format(doc, 80)
["hello", "world"]

Характеристики

container_doc(
  t(),
  [any()],
  t(),
  Inspect.Opts.t(),
  (term(), Inspect.Opts.t() -> t()),
  keyword()
) :: t()

Оборачивает collection в left и right в соответствии с пределом и содержимым.

Использует заданные left и right документы в качестве окружающих, а документ-разделитель separator для разделения элементов в docs. Если все элементы в коллекции являются простыми документами (текстами или строками), то эта функция пытается расположить как можно больше элементов в одной строке. Если они не простые, то по одной записи в строке, если они не помещаются.

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

Параметры

• :separator — разделитель, используемый между каждым документом
• :break — Если :strict, всегда вставлять разрыв между каждым элементом. Если :flex, вставлять разрывы только при необходимости. Если :maybe, выбирать :flex только если все элементы являются текстовыми, в противном случае :strict

Примеры

iex> inspect_opts = %Inspect.Opts{limit: :infinity}
iex> fun = fn i, _opts -> to_string(i) end
iex> doc = Inspect.Algebra.container_doc("[", Enum.to_list(1..5), "]", inspect_opts, fun)
iex> Inspect.Algebra.format(doc, 5) |> IO.iodata_to_binary()
"[1,\n 2,\n 3,\n 4,\n 5]"

iex> inspect_opts = %Inspect.Opts{limit: 3}
iex> fun = fn i, _opts -> to_string(i) end
iex> doc = Inspect.Algebra.container_doc("[", Enum.to_list(1..5), "]", inspect_opts, fun)
iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()
"[1, 2, 3, ...]"

iex> inspect_opts = %Inspect.Opts{limit: 3}
iex> fun = fn i, _opts -> to_string(i) end
iex> opts = [separator: "!"]
iex> doc = Inspect.Algebra.container_doc("[", Enum.to_list(1..5), "]", inspect_opts, fun, opts)
iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary()
"[1! 2! 3! ...]"

Характеристики

empty() :: :doc_nil

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

Примеры

iex> Inspect.Algebra.empty()
:doc_nil

Характеристики

flex_break(binary()) :: doc_break()

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

Гибкий разрыв всё ещё заставляет группу прерываться, как break/1, но он переоценивается при отображении документа.

Например, возьмём документ группы, представленный как [1, 2, 3] где пробел после каждой запятой является разрывом. Когда документ выше не помещается в одну строку, все разрывы активируются, заставляя документ отображаться как:

[1,
 2,
 3]

Однако, если используются гибкие разрывы, каждый разрыв переоценивается при отображении, поэтому документ может быть отображён как:

[1, 2,
 3]

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

Эта функция используется функцией container_doc/6 и аналогичными для максимизации количества записей в одной строке.

Характеристики

flex_glue(t(), binary(), t()) :: t()

Присоединяет два документа (doc1 и doc2) вставляя flex_break/1, заданный break_string между ними.

Эта функция используется функцией container_doc/6 и аналогичными для максимизации количества записей в одной строке.

Характеристики

fold_doc([t()], (t(), t() -> t())) :: t()

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

Список документов складывается «справа»; в этом функция аналогична List.foldr/3, за исключением того, что она не ожидает начального аккумулятора и использует последний элемент docs в качестве начального аккумулятора.

Примеры

iex> docs = ["A", "B", "C"]
iex> docs =
...>   Inspect.Algebra.fold_doc(docs, fn doc, acc ->
...>     Inspect.Algebra.concat([doc, "!", acc])
...>   end)
iex> Inspect.Algebra.format(docs, 80)
["A", "!", "B", "!", "C"]

Характеристики

force_unfit(t()) :: doc_force()

Принудительно устанавливает текущую группу в состояние «не подходит».

Характеристики

format(t(), non_neg_integer() | :infinity) :: iodata()

Форматирует заданный документ для заданной ширины.

Принимает максимальную ширину и документ для печати в качестве аргументов и возвращает представление данных ввода-вывода лучшей компоновки для размещения документа в заданной ширине.

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

Примеры

iex> doc = Inspect.Algebra.glue("hello", " ", "world")
iex> doc = Inspect.Algebra.group(doc)
iex> doc |> Inspect.Algebra.format(30) |> IO.iodata_to_binary()
"hello world"
iex> doc |> Inspect.Algebra.format(10) |> IO.iodata_to_binary()
"hello\nworld"

Характеристики

glue(t(), binary(), t()) :: t()

Присоединяет два документа (doc1 и doc2) вставляя заданный разрыв break_string между ними.

Для получения дополнительной информации о том, как вставляется разрыв, см. break/1.

Примеры

iex> doc = Inspect.Algebra.glue("hello", "world")
iex> Inspect.Algebra.format(doc, 80)
["hello", " ", "world"]

iex> doc = Inspect.Algebra.glue("hello", "\t", "world")
iex> Inspect.Algebra.format(doc, 80)
["hello", "\t", "world"]

Характеристики

group(t(), :self | :inherit) :: doc_group()

Возвращает группу, содержащую указанный документ doc.

Документы в группе пытаются отображаться вместе по возможности.

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

Примеры

iex> doc =
...>   Inspect.Algebra.group(
...>     Inspect.Algebra.concat(
...>       Inspect.Algebra.group(
...>         Inspect.Algebra.concat(
...>           "Hello,",
...>           Inspect.Algebra.concat(
...>             Inspect.Algebra.break(),
...>             "A"
...>           )
...>         )
...>       ),
...>       Inspect.Algebra.concat(
...>         Inspect.Algebra.break(),
...>         "B"
...>       )
...>     )
...>   )
iex> Inspect.Algebra.format(doc, 80)
["Hello,", " ", "A", " ", "B"]
iex> Inspect.Algebra.format(doc, 6)
["Hello,", "\n", "A", "\n", "B"]

Характеристики

line() :: t()

Обязательный перевод строки.

Группа с переводами строк поместится, если все строки в группе поместятся.

Примеры

iex> doc =
...>   Inspect.Algebra.concat(
...>     Inspect.Algebra.concat(
...>       "Hughes",
...>       Inspect.Algebra.line()
...>     ),
...>     "Wadler"
...>   )
iex> Inspect.Algebra.format(doc, 80)
["Hughes", "\n", "Wadler"]

Характеристики

line(t(), t()) :: t()

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

См. line/0.

Примеры

iex> doc = Inspect.Algebra.line("Hughes", "Wadler")
iex> Inspect.Algebra.format(doc, 80)
["Hughes", "\n", "Wadler"]

Характеристики

nest(t(), non_neg_integer() | :cursor | :reset, :always | :break) :: doc_nest()

Вкладывает заданный документ на заданный level.

Если уровень — целое число, это отступ, добавляемый к переводу строки при его появлении. Если уровень — :cursor, текущая позиция «курсора» в документе становится вложением. Если уровень — :reset, он устанавливается обратно в 0.

mode может быть :always, что означает, что вложение всегда происходит, или :break, что означает, что вложение происходит только внутри группы, которая была разорвана.

Примеры

iex> doc = Inspect.Algebra.nest(Inspect.Algebra.glue("hello", "world"), 5)
iex> doc = Inspect.Algebra.group(doc)
iex> Inspect.Algebra.format(doc, 5)
["hello", "\n     ", "world"]

Характеристики

next_break_fits(t(), :enabled | :disabled) :: doc_fits()

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

mode может быть :enabled или :disabled. При :enabled, документ будет считаться подходящим как только найдётся следующий разрыв, фактически отменяя разрыв. Также будут проигнорированы любые инструкции force_unfit/1 при поиске следующего разрыва.

При отключении, она ведёт себя как обычно и проигнорирует любые последующие инструкции next_break_fits/2.

Примеры

Это используется в форматировщике кода Elixir, чтобы избежать разрыва кода в определённых местах. Например, рассмотрим этот код:

some_function_call(%{..., key: value, ...})

Теперь представьте, что этот код не помещается в строку. Форматировщик кода вводит разрывы внутри ( и ) и внутри %{ и }. Поэтому документ будет разбит как:

some_function_call(
  %{
    ...,
    key: value,
    ...
  }
)

Форматировщик оборачивает документ алгебры, представляющий карту, в next_break_fits/1, поэтому код отформатирован как:

some_function_call(%{
  ...,
  key: value,
  ...
})

Характеристики

space(t(), t()) :: t()

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

Примеры

iex> doc = Inspect.Algebra.space("Hughes", "Wadler")
iex> Inspect.Algebra.format(doc, 5)
["Hughes", " ", "Wadler"]

Характеристики

string(String.t()) :: doc_string()

Создаёт документ, представленный строкой.

Хотя Inspect.Algebra принимает двоичные данные как документы, они учитываются по размеру в байтах. С другой стороны, документы string измеряются по количеству графем для определения размера документа.

Примеры

Следующий документ содержит 10 байт, и поэтому он не форматируется до ширины 9 без разрывов:

iex> doc = Inspect.Algebra.glue("olá", " ", "mundo")
iex> doc = Inspect.Algebra.group(doc)
iex> Inspect.Algebra.format(doc, 9)
["olá", "\n", "mundo"]

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

iex> string = Inspect.Algebra.string("olá")
iex> doc = Inspect.Algebra.glue(string, " ", "mundo")
iex> doc = Inspect.Algebra.group(doc)
iex> Inspect.Algebra.format(doc, 9)
["olá", " ", "mundo"]

Характеристики

to_doc(any(), Inspect.Opts.t()) :: t()

Преобразует термин Elixir в документ алгебры в соответствии с протоколом Inspect.