@spec camelize(String.t()) :: String.t()

Преобразует заданную строку в формат CamelCase.

Эта функция была разработана для преобразования идентификаторов/токенов языка в CamelCase, поэтому она принадлежит модулю Macro. Не используйте её как общий механизм для преобразования строк в CamelCase, так как она не поддерживает Unicode или символы, которые не являются допустимыми в Elixir-идентификаторах.

Примеры

iex> Macro.camelize("foo_bar")
"FooBar"

iex> Macro.camelize("foo/bar")
"Foo.Bar"

Если присутствуют заглавные буквы, они никак не изменяются в качестве механизма сохранения аббревиатур:

iex> Macro.camelize("API.V1")
"API.V1"
iex> Macro.camelize("API_SPEC")
"API_SPEC"

@spec classify_atom(atom()) :: :alias | :identifier | :quoted | :unquoted

Классифицирует atom в выполнении на основе его возможного размещения в AST.

Возвращает один из следующих атомов:

• :alias — атом представляет собой псевдоним

• :identifier — атом может использоваться в качестве переменной или локального вызова функции (а также быть необрамлённым атомом)

• :unquoted — атом может использоваться в его необрамлённом виде, включает операторы и атомы с @ в них

• :quoted — все остальные атомы, которые могут использоваться только в своей обрамлённой форме

Большинство операторов будут :unquoted, например :+, за некоторыми исключениями, которые возвращают :quoted из-за неоднозначности, например :"::". Используйте operator?/2 для проверки, является ли данный атом оператором.

Примеры

iex> Macro.classify_atom(:foo)
:identifier
iex> Macro.classify_atom(Foo)
:alias
iex> Macro.classify_atom(:foo@bar)
:unquoted
iex> Macro.classify_atom(:+)
:unquoted
iex> Macro.classify_atom(:Foo)
:unquoted
iex> Macro.classify_atom(:"with spaces")
:quoted

@spec dbg(t(), t(), Macro.Env.t()) :: t()

По умолчанию, бэкенд для Kernel.dbg/2.

Эта функция предоставляет бэкенд по умолчанию для Kernel.dbg/2. Подробнее см. документацию Kernel.dbg/2.

Эта функция:

• выводит информацию о заданном env
• выводит информацию о code и возвращаемом значении (используя opts для проверки терминов)
• возвращает значение, возвращённое при вычислении code

Вы можете вызвать эту функцию напрямую для создания бэкендов Kernel.dbg/2, которые обращаются к этой функции.

@spec decompose_call(t()) :: {atom(), [t()]} | {t(), atom(), [t()]} | :error

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

Возвращает :error при неверном синтаксисе вызова.

Примеры

iex> Macro.decompose_call(quote(do: foo))
{:foo, []}

iex> Macro.decompose_call(quote(do: foo()))
{:foo, []}

iex> Macro.decompose_call(quote(do: foo(1, 2, 3)))
{:foo, [1, 2, 3]}

iex> Macro.decompose_call(quote(do: Elixir.M.foo(1, 2, 3)))
{{:__aliases__, [], [:Elixir, :M]}, :foo, [1, 2, 3]}

iex> Macro.decompose_call(quote(do: 42))
:error

iex> Macro.decompose_call(quote(do: {:foo, [], []}))
:error

@spec escape(
  term(),
  keyword()
) :: t()

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

Примеры

iex> Macro.escape(:foo)
:foo

iex> Macro.escape({:a, :b, :c})
{:{}, [], [:a, :b, :c]}

iex> Macro.escape({:unquote, [], [1]}, unquote: true)
1

Опции

• :unquote — если true, функция оставляет unquote/1 и unquote_splicing/1 не экранированными, фактически раскомментируя содержимое при экранировании. Эта опция полезна только при экранировании AST, которые могут содержать цитируемые фрагменты. По умолчанию false.

• :prune_metadata — если true, удаляет метаданные из экранированных узлов AST. Обратите внимание, что эта опция изменяет семантику экранированного кода, и её следует использовать только при экранировании AST. По умолчанию false.

  Например, ExUnit хранит AST каждого утверждения, поэтому при ошибке утверждения мы можем показать пользователям фрагменты кода. Без этой опции каждый раз, когда модуль теста компилируется, мы получаем различный MD5 байткода модуля, поскольку AST содержит метаданные, такие как счётчики, специфичные для среды компиляции. Удаляя метаданные, мы гарантируем детерминированность модуля и уменьшаем количество данных, которые ExUnit должен хранить. Сохраняется только минимальный объём метаданных, таких как :line и :no_parens.

Сравнение с quote/2

Функция escape/2 иногда путают с quote/2, поскольку примеры выше ведут себя одинаково с обеими функциями. Основное различие лучше всего иллюстрируется, когда значение для экранирования хранится в переменной.

iex> Macro.escape({:a, :b, :c})
{:{}, [], [:a, :b, :c]}
iex> quote do: {:a, :b, :c}
{:{}, [], [:a, :b, :c]}

iex> value = {:a, :b, :c}
iex> Macro.escape(value)
{:{}, [], [:a, :b, :c]}

iex> quote do: value
{:value, [], __MODULE__}

iex> value = {:a, :b, :c}
iex> quote do: unquote(value)
{:a, :b, :c}

escape/2 используется для экранирования значений (либо непосредственно переданных, либо связанных переменной), а quote/2 создаёт деревья синтаксического анализа для выражений.

@spec expand(t(), Macro.Env.t()) :: t()

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

Обратите внимание, что эта функция не проходит по дереву AST, а расширяет только корневой узел.

Эта функция использует expand_once/2 внутри. Проверьте её для получения дополнительной информации и примеров.

@spec expand_literals(t(), Macro.Env.t()) :: t()

Расширяет все литералы в ast с заданной env.

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

Macro.expand_literals(ast, %{env | function: {:my_code, 1}})

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

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

@spec expand_literals(t(), acc, (t(), acc -> {t(), acc})) :: t() when acc: term()

Расширяет все литералы в ast с заданной acc и fun.

fun будет вызвана с расширяемым узлом AST и acc, и должна вернуть новый узел с acc. Это обобщённая версия expand_literals/2, которая поддерживает пользовательскую функцию расширения. Пожалуйста, обратитесь к expand_literals/2 для примеров использования и ловушек.

@spec expand_once(t(), Macro.Env.t()) :: t()

Принимает узел AST и расширяет его один раз.

Расширяются следующие элементы:

• Макросы (локальные или удалённые)
• Псевдонимы расширяются (если возможно) и возвращают атомы
• Макросы среды компиляции (__CALLER__/0, __DIR__/0, __ENV__/0 и __MODULE__/0)
• Чтение атрибутов модуля (@foo)

Если выражение не может быть расширено, оно возвращает само выражение. Эта функция не проходит по дереву AST, а расширяет только корневой узел.

expand_once/2 выполняет расширение только один раз. См. expand/2 для выполнения расширения до тех пор, пока узел больше не может быть расширен.

Примеры

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

Рассмотрим реализацию ниже:

defmacro defmodule_with_length(name, do: block) do
  length = length(Atom.to_charlist(name))

  quote do
    defmodule unquote(name) do
      def name_length, do: unquote(length)
      unquote(block)
    end
  end
end

При вызове так:

defmodule_with_length My.Module do
  def other_function, do: ...
end

Компиляция завершится ошибкой, потому что My.Module, когда цитируется, не является атомом, а деревом синтаксического анализа, как показано ниже:

{:__aliases__, [], [:My, :Module]}

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

alias MyHelpers, as: My

defmodule_with_length My.Module do
  def other_function, do: ...
end

Конечное имя модуля будет MyHelpers.Module, а не My.Module. С помощью Macro.expand/2 такие псевдонимы учитываются. Также расширяются локальные и удалённые макросы. Мы могли бы переписать наш макрос выше, используя эту функцию так:

defmacro defmodule_with_length(name, do: block) do
  expanded = Macro.expand(name, __CALLER__)
  length = length(Atom.to_charlist(expanded))

  quote do
    defmodule unquote(name) do
      def name_length, do: unquote(length)
      unquote(block)
    end
  end
end

@spec generate_arguments(0, context :: atom()) :: []

@spec generate_arguments(pos_integer(), context) :: [{atom(), [], context}, ...]
when context: atom()

Генерирует узлы AST для заданного числа переменных аргументов, используя Macro.var/2.

Обратите внимание, что аргументы не уникальны. Если впоследствии вам нужно получить доступ к тем же переменным, вы можете вызвать эту функцию с теми же входными данными. Используйте generate_unique_arguments/2 для генерации уникальных аргументов, которые нельзя перезаписать.

Примеры

iex> Macro.generate_arguments(2, __MODULE__)
[{:arg1, [], __MODULE__}, {:arg2, [], __MODULE__}]

@spec generate_unique_arguments(0, context :: atom()) :: []

@spec generate_unique_arguments(pos_integer(), context) :: [
  {atom(), [{:counter, integer()}], context},
  ...
]
when context: atom()

Генерирует узлы AST для заданного числа переменных аргументов, используя Macro.unique_var/2.

Примеры

iex> [var1, var2] = Macro.generate_unique_arguments(2, __MODULE__)
iex> {:arg1, [counter: c1], __MODULE__} = var1
iex> {:arg2, [counter: c2], __MODULE__} = var2
iex> is_integer(c1) and is_integer(c2)
true

@spec inspect_atom(:literal | :key | :remote_call, atom()) :: binary()

Проверяет atom в соответствии с различными форматами исходного кода.

Атом можно проверить в соответствии с тремя различными форматами, в которых он встречается в AST: как литерал (:literal), как ключ (:key) или как имя функции удалённого вызова (:remote_call).

Примеры

Как литерал

Литералы включают обычные атомы, процитированные атомы, операторы, псевдонимы и специальные nil, true, и false атомы.

iex> Macro.inspect_atom(:literal, nil)
"nil"
iex> Macro.inspect_atom(:literal, :foo)
":foo"
iex> Macro.inspect_atom(:literal, :<>)
":<>"
iex> Macro.inspect_atom(:literal, :Foo)
":Foo"
iex> Macro.inspect_atom(:literal, Foo.Bar)
"Foo.Bar"
iex> Macro.inspect_atom(:literal, :"with spaces")
":\"with spaces\""

Как ключ

Проверка атома в качестве ключа списка ключевых слов или карты.

iex> Macro.inspect_atom(:key, :foo)
"foo:"
iex> Macro.inspect_atom(:key, :<>)
"<>:"
iex> Macro.inspect_atom(:key, :Foo)
"Foo:"
iex> Macro.inspect_atom(:key, :"with spaces")
"\"with spaces\":"

Как имя удалённого вызова

Проверка атома как имени функции удалённого вызова.

iex> Macro.inspect_atom(:remote_call, :foo)
"foo"
iex> Macro.inspect_atom(:remote_call, :<>)
"<>"
iex> Macro.inspect_atom(:remote_call, :Foo)
"\"Foo\""
iex> Macro.inspect_atom(:remote_call, :"with spaces")
"\"with spaces\""

@spec operator?(name :: atom(), arity()) :: boolean()

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

Примеры

iex> Macro.operator?(:not_an_operator, 3)
false
iex> Macro.operator?(:.., 0)
true
iex> Macro.operator?(:+, 1)
true
iex> Macro.operator?(:++, 2)
true
iex> Macro.operator?(:..//, 3)
true

Возвращает путь к узлу в ast, в котором fun возвращает true.

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

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

Примеры

iex> Macro.path(quote(do: [1, 2, 3]), & &1 == 3)
[3, [1, 2, 3]]

iex> Macro.path(quote(do: Foo.bar(3)), & &1 == 3)
[3, quote(do: Foo.bar(3))]

iex> Macro.path(quote(do: %{foo: [bar: :baz]}), & &1 == :baz)
[
  :baz,
  {:bar, :baz},
  [bar: :baz],
  {:foo, [bar: :baz]},
  {:%{}, [], [foo: [bar: :baz]]}
]

@spec pipe(t(), t(), integer()) :: t()

Передаёт expr в call_args в заданной position.

Эта функция может использоваться для реализации функциональности типа |>. Например, сам |> реализован как:

defmacro left |> right do
  Macro.pipe(left, right, 0)
end

expr — это AST выражения. call_args должен быть AST вызова, иначе эта функция вызовет ошибку. Например, рассмотрим оператор конвейера |>/2, который использует эту функцию для построения конвейеров.

Даже если выражение передаётся в AST, это не обязательно означает, что AST является корректным. Например, вы можете передать аргумент в div/2, фактически превратив его в вызов div/3, которая является функцией, которая по умолчанию не существует. Код вызовет ошибку, если функция div/3 не определена локально.

@spec postwalk(t(), (t() -> t())) :: t()

Эта функция работает как prewalk/2, но выполняет обход цитируемых выражений в глубину, в пост-порядке.

@spec postwalk(t(), any(), (t(), any() -> {t(), any()})) :: {t(), any()}

Эта функция работает как prewalk/3, но выполняет обход цитируемых выражений в глубину, в пост-порядке, используя накопитель.

@spec postwalker(t()) :: Enumerable.t()

Возвращает перечислимый объект, который обходит ast в глубину, в пост-порядке.

Примеры

iex> ast = quote do: foo(1, "abc")
iex> Enum.map(Macro.postwalker(ast), & &1)
[1, "abc", {:foo, [], [1, "abc"]}]

@spec prewalk(t(), (t() -> t())) :: t()

Выполняет обход цитируемых выражений в глубину, в пред-порядке.

Возвращает новый AST, где каждый узел является результатом вызова fun на соответствующем узле ast.

Примеры

iex> ast = quote do: 5 + 3 * 7
iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
iex> new_ast = Macro.prewalk(ast, fn
...>   {:+, meta, children} -> {:*, meta, children}
...>   {:*, meta, children} -> {:+, meta, children}
...>   other -> other
...> end)
iex> {:*, _, [5, {:+, _, [3, 7]}]} = new_ast
iex> Code.eval_quoted(ast)
{26, []}
iex> Code.eval_quoted(new_ast)
{50, []}

@spec prewalk(t(), any(), (t(), any() -> {t(), any()})) :: {t(), any()}

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

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

Примеры

iex> ast = quote do: 5 + 3 * 7
iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
iex> {new_ast, acc} = Macro.prewalk(ast, [], fn
...>   {:+, meta, children}, acc -> {{:*, meta, children}, [:+ | acc]}
...>   {:*, meta, children}, acc -> {{:+, meta, children}, [:* | acc]}
...>   other, acc -> {other, acc}
...> end)
iex> {{:*, _, [5, {:+, _, [3, 7]}]}, [:*, :+]} = {new_ast, acc}
iex> Code.eval_quoted(ast)
{26, []}
iex> Code.eval_quoted(new_ast)
{50, []}

@spec prewalker(t()) :: Enumerable.t()

Возвращает перечислимый объект, который обходит ast в глубину, в пред-порядке.

Примеры

iex> ast = quote do: foo(1, "abc")
iex> Enum.map(Macro.prewalker(ast), & &1)
[{:foo, [], [1, "abc"]}, 1, "abc"]

@spec quoted_literal?(t()) :: boolean()

Возвращает true, если данное цитируемое выражение представляет цитируемый литерал.

Атомы и числа всегда являются литералами. Бинарные данные, списки, кортежи, карты и структуры являются литералами только в том случае, если все их элементы также являются литералами.

Примеры

iex> Macro.quoted_literal?(quote(do: "foo"))
true
iex> Macro.quoted_literal?(quote(do: {"foo", 1}))
true
iex> Macro.quoted_literal?(quote(do: {"foo", 1, :baz}))
true
iex> Macro.quoted_literal?(quote(do: %{foo: "bar"}))
true
iex> Macro.quoted_literal?(quote(do: %URI{path: "/"}))
true
iex> Macro.quoted_literal?(quote(do: URI.parse("/")))
false
iex> Macro.quoted_literal?(quote(do: {foo, var}))
false

@spec special_form?(name :: atom(), arity()) :: boolean()

Возвращает true если данное имя и арность являются специальной формой.

@spec struct!(module, Macro.Env.t()) :: %{
  :__struct__ => module,
  optional(atom()) => any()
}
when module: module()

Расширяет структуру, заданную module в заданном env.

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

Она вызовет CompileError если структура недоступна. Начиная с Elixir v1.12, вызов этой функции также добавляет зависимость экспорта на заданную структуру.

@spec to_string(t()) :: String.t()

Преобразует данный выражение AST в строку.

Это удобная функция для преобразования AST в строку, которая отбрасывает всю форматирование исходного кода и добавляет новые строки вокруг 98 символов. См. Code.quoted_to_algebra/2 как функцию более низкого уровня с большим контролем над форматированием.

Примеры

iex> Macro.to_string(quote(do: foo.bar(1, 2, 3)))
"foo.bar(1, 2, 3)"

@spec to_string(t(), (t(), String.t() -> String.t())) :: String.t()

Преобразует заданное выражение AST в строку.

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

Эта функция отбрасывает все форматирования исходного кода.

Примеры

Macro.to_string(quote(do: 1 + 2), fn
  1, _string -> "one"
  2, _string -> "two"
  _ast, string -> string
end)
#=> "one + two"

@spec traverse(t(), any(), (t(), any() -> {t(), any()}), (t(), any() -> {t(), any()})) ::
  {t(), any()}

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

Возвращает кортеж, где первый элемент — новый AST, а второй — конечный аккумулятор. Новый AST является результатом вызова pre для каждого узла ast в фазе «предобработка» и post в фазе «послеобработка».

Примеры

iex> ast = quote do: 5 + 3 * 7
iex> {:+, _, [5, {:*, _, [3, 7]}]} = ast
iex> {new_ast, acc} =
...>  Macro.traverse(
...>    ast,
...>    [],
...>    fn
...>      {:+, meta, children}, acc -> {{:-, meta, children}, [:- | acc]}
...>      {:*, meta, children}, acc -> {{:/, meta, children}, [:/ | acc]}
...>      other, acc -> {other, acc}
...>    end,
...>    fn
...>      {:-, meta, children}, acc -> {{:min, meta, children}, [:min | acc]}
...>      {:/, meta, children}, acc -> {{:max, meta, children}, [:max | acc]}
...>      other, acc -> {other, acc}
...>    end
...>  )
iex> {:min, _, [5, {:max, _, [3, 7]}]} = new_ast
iex> [:min, :max, :/, :-] = acc
iex> Code.eval_quoted(new_ast)
{5, []}

@spec underscore(module() | atom() | String.t()) :: String.t()

Преобразует заданный аргумент в строку с форматированием «подчёркивание-слэш».

Аргумент должен быть атомом или строкой. Если задан атом, предполагается, что это модуль Elixir, поэтому он преобразуется в строку, а затем обрабатывается.

Эта функция была разработана для форматирования идентификаторов/токенов языка с использованием формата «подчёркивание-слэш», поэтому она принадлежит модулю Macro. Не используйте её как общий механизм подчёркивания строк, так как она не поддерживает Unicode или символы, которые не являются допустимыми в идентификаторах Elixir.

Примеры

iex> Macro.underscore("FooBar")
"foo_bar"

iex> Macro.underscore("Foo.Bar")
"foo/bar"

iex> Macro.underscore(Foo.Bar)
"foo/bar"

В общем случае, underscore можно рассматривать как обратную функцию camelize, однако в некоторых случаях форматирование может быть потеряно:

iex> Macro.underscore("SAPExample")
"sap_example"

iex> Macro.camelize("sap_example")
"SapExample"

iex> Macro.camelize("hello_10")
"Hello10"

iex> Macro.camelize("foo/bar")
"Foo.Bar"

@spec unescape_string(String.t()) :: String.t()

Разворачивает символы в строке.

Это поведение разворачивания, используемое по умолчанию в Elixir в одинарных и двойных кавычках. Смотрите unescape_string/2 для получения информации о том, как настроить карту экранирования.

В этом случае Elixir экранирует следующие символы: \0, \a, \b, \d, \e, \f, \n, \r, \s, \t и \v. Байты могут быть заданы в шестнадцатеричном формате через \xNN, а кодовые точки Unicode через \uNNNN экранирование.

Эта функция часто используется в реализации сигилов (например, ~r, ~s и другие), которые получают необработанную, неэкранированную строку, и её можно использовать в любом месте, где необходимо имитировать обработку строк в Elixir.

Примеры

iex> Macro.unescape_string("example\\n")
"example\n"

В примере выше мы передаём строку с \n экранированным и возвращаем версию с ним раэкранированным.

@spec unescape_string(String.t(), (non_neg_integer() -> non_neg_integer() | false)) ::
  String.t()

Разворачивает символы в строке согласно заданному отображению.

Смотрите unescape_string/1, если вы хотите использовать ту же карту экранирования, что и в одинарных и двойных кавычках Elixir.

Функция отображения

Функция отображения получает целое число, представляющее кодовую точку символа, который нужно раэкранировать. Также есть специальные атомы :newline, :unicode, и :hex, которые управляют символами новой строки, Unicode и экранирования соответственно.

Вот функция отображения по умолчанию, реализованная в Elixir:

def unescape_map(:newline), do: true
def unescape_map(:unicode), do: true
def unescape_map(:hex), do: true
def unescape_map(?0), do: ?0
def unescape_map(?a), do: ?\a
def unescape_map(?b), do: ?\b
def unescape_map(?d), do: ?\d
def unescape_map(?e), do: ?\e
def unescape_map(?f), do: ?\f
def unescape_map(?n), do: ?\n
def unescape_map(?r), do: ?\r
def unescape_map(?s), do: ?\s
def unescape_map(?t), do: ?\t
def unescape_map(?v), do: ?\v
def unescape_map(e), do: e

Если функция unescape_map/1 возвращает false, символ не экранируется, и обратная косая черта сохраняется в строке.

Примеры

Использование функции unescape_map/1 определённой выше — просто:

Macro.unescape_string("example\\n", &unescape_map(&1))

@spec unique_var(var, context) :: {var, [{:counter, integer()}], context}
when var: atom(), context: atom()

Генерирует узел AST, представляющий уникальную переменную, заданную атомами var и context.

Вызов этой функции с теми же аргументами сгенерирует другую переменную с собственным уникальным счётчиком. См. var/2 для альтернативы.

Примеры

iex> {:foo, [counter: c], __MODULE__} = Macro.unique_var(:foo, __MODULE__)
iex> is_integer(c)
true

@spec unpipe(t()) :: [t()]

Разбивает выражение канала в список.

AST для канала (последовательности применений |>/2) похож на AST последовательности бинарных операторов или приложений функций: выражение верхнего уровня — это самый правый :|> (который выполняется последним), а его левая и правая части — это его аргументы:

quote do: 100 |> div(5) |> div(2)
#=> {:|>, _, [arg1, arg2]}

В примере выше, канал |>/2 является самым правым каналом; arg1 — это AST для 100 |> div(5), а arg2 — это AST для div(2).

Часто бывает полезно иметь AST для такого канала как список приложений функций. Эта функция делает именно это:

Macro.unpipe(quote do: 100 |> div(5) |> div(2))
#=> [{100, 0}, {{:div, [], [5]}, 0}, {{:div, [], [2]}, 0}]

Мы получаем список, который непосредственно следует за каналом: сначала 100, затем div(5) (точнее, его AST), затем div(2). 0 в качестве второго элемента кортежей — это позиция предыдущего элемента в канале внутри текущего применения функции: {{:div, [], [5]}, 0} означает, что предыдущий элемент (100) будет вставлен как 0-й (первый) аргумент функции div/2, так что AST для этой функции станет {:div, [], [100, 5]} (div(100, 5)).

@spec update_meta(t(), (keyword() -> keyword())) :: t()

Применяет заданную функцию к метаданным узла, если они содержатся.

Это часто полезно, когда используется с Macro.prewalk/2, чтобы удалить информацию, такую как строки и гигиенические счётчики из выражения для хранения или сравнения.

Примеры

iex> quoted = quote line: 10, do: sample()
{:sample, [line: 10], []}
iex> Macro.update_meta(quoted, &Keyword.delete(&1, :line))
{:sample, [], []}

@spec validate(term()) :: :ok | {:error, term()}

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

См. тип Macro.t/0 для полного описания допустимого выражения в кавычках.

Возвращает :ok если выражение допустимо. В противном случае возвращает кортеж в форме {:error, remainder}, где remainder — недопустимая часть выражения в кавычках.

Примеры

iex> Macro.validate({:two_element, :tuple})
:ok
iex> Macro.validate({:three, :element, :tuple})
{:error, {:three, :element, :tuple}}

iex> Macro.validate([1, 2, 3])
:ok
iex> Macro.validate([1, 2, 3, {4}])
{:error, {4}}

@spec var(var, context) :: {var, [], context} when var: atom(), context: atom()

Генерирует узел AST, представляющий переменную, заданную атомами var и context.

Обратите внимание, что эта переменная не уникальна. Если вам нужно позже получить доступ к этой же переменной, вы можете снова вызвать var/2 с теми же аргументами. Используйте unique_var/2 для генерации уникальной переменной, которую нельзя переопределить.

Примеры

Для создания переменной требуется контекст. Большинство раз, для сохранения гигиены, контекст должен быть __MODULE__/0:

iex> Macro.var(:foo, __MODULE__)
{:foo, [], __MODULE__}

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

iex> Macro.var(:foo, nil)
{:foo, [], nil}