Модуль behaviour

Предоставляет функции для работы с модулями во время компиляции.

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

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

Атрибуты модуля

Каждый модуль может быть снабжен одним или несколькими атрибутами. Следующие атрибуты в настоящее время определены Elixir:

`@after_compile`

Обработчик, который будет вызван сразу после компиляции текущего модуля. Принимает модуль или {module, function_name}. См. раздел «Обработчики компиляции» ниже.

`@before_compile`

Обработчик, который будет вызван перед компиляцией модуля. Принимает модуль или {module, function_or_macro_name} кортеж. См. раздел «Обработчики компиляции» ниже.

`@behaviour`

Обратите внимание на британский правописание!

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

Например, вы можете указать поведение URI.Parser следующим образом:

defmodule URI.Parser do
  @doc "Defines a default port"
  @callback default_port() :: integer

  @doc "Parses the given URL"
  @callback parse(uri_info :: URI.t()) :: URI.t()
end

А затем модуль может использовать его как:

defmodule URI.HTTP do
  @behaviour URI.Parser
  def default_port(), do: 80
  def parse(info), do: info
end

Если поведение изменяется или URI.HTTP не реализует один из обратных вызовов, будет выведено предупреждение.

`@impl`

Чтобы помочь в правильной реализации поведения, вы можете необязательно объявить @impl для реализованных обратных вызовов поведения. Это делает обратные вызовы явными и может помочь вам поймать ошибки в вашем коде. Компилятор выдаст предупреждение в этих случаях:

если вы помечаете функцию с @impl , когда эта функция не является обратным вызовом.
если вы не помечаете функцию с @impl , когда другие функции помечены с @impl . Если вы помечаете одну функцию с @impl , вы должны пометить все другие обратные вызовы для этого поведения как @impl.

@impl работает на основе контекста. Если вы генерируете функцию через макрос и помечаете её @impl , это не повлияет на модуль, в котором эта функция сгенерирована.

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

Используя @impl , пример выше можно переписать как:

defmodule URI.HTTP do
  @behaviour URI.Parser

  @impl true
  def default_port(), do: 80

  @impl true
  def parse(info), do: info
end

Вы можете передать false , true или конкретное поведение в @impl.

defmodule Foo do
  @behaviour Bar
  @behaviour Baz

  # Will warn if neither Bar nor Baz specify a callback named bar/0.
  @impl true
  def bar(), do: :ok

  # Will warn if Baz does not specify a callback named baz/0.
  @impl Baz
  def baz(), do: :ok
end

Код теперь более читабелен, так как теперь ясно, какие функции являются частью вашего API, а какие реализуют обратные вызовы. Для усиления этой идеи, @impl true автоматически помечает функцию как @doc false , отключая документацию, если @doc явно не задан.

`@compile`

Определяет параметры для компиляции модуля. Это используется для настройки как компиляторов Elixir, так и Erlang, а также любых других этапов компиляции, добавленных внешними инструментами. Например:

defmodule MyModule do
  @compile {:inline, my_fun: 1}

  def my_fun(arg) do
    to_string(arg)
  end
end

Несколько применений @compile будут накапливаться, а не перезаписывать предыдущие. См. раздел «Параметры компиляции» ниже.

`@deprecated`

Предоставляет причину устаревания функции. Например:

defmodule Keyword do
  @deprecated "Use Kernel.length/1 instead"
  def size(keyword) do
    length(keyword)
  end
end

Компилятор Mix автоматически ищет вызовы устаревших модулей и выводит предупреждения во время компиляции, вычисленные с помощью mix xref warnings.

Использование атрибута @deprecated также будет отражено в документации данной функции и макроса. Вы можете выбрать между атрибутом @deprecated и метаданными документации для предоставления жёстких устаревших (с предупреждениями) и мягких устаревших (без предупреждений) вариантов:

Это мягкое устаревание, так как оно просто помечает документацию как устаревшую:

@doc deprecated: "Use Kernel.length/1 instead"
def size(keyword)

Это жёсткое устаревание, так как оно генерирует предупреждения и помечает документацию как устаревшую:

@deprecated "Use Kernel.length/1 instead"
def size(keyword)

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

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

`@doc` и `@typedoc`

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

Принимает строку (часто heredoc) или false , где @doc false сделает сущность невидимой для инструментов извлечения документации, таких как ExDoc. Например:

defmodule MyModule do
  @typedoc "This type"
  @typedoc since: "1.1.0"
  @type t :: term

  @doc "Hello world"
  @doc since: "1.1.0"
  def hello do
    "world"
  end

  @doc """
  Sums `a` to `b`.
  """
  def sum(a, b) do
    a + b
  end
end

Как видно из примера выше, @doc и @typedoc также принимают список ключевых слов, который служит способом предоставления произвольных метаданных о сущности. Инструменты, такие как ExDoc и IEx, могут использовать эту информацию для отображения аннотаций. Распространённый случай использования since , который может быть использован для анотации версии, в которой функция была введена.

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

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

`@dialyzer`

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

Принимает атом, кортеж или список атомов и кортежей. Например:

defmodule MyModule do
  @dialyzer {:nowarn_function, my_fun: 1}

  def my_fun(arg) do
    M.not_a_function(arg)
  end
end

Список поддерживаемых предупреждений см. в :dialyzer модуле.

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

`@external_resource`

Указывает внешний ресурс для текущего модуля.

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

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

`@file`

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

defmodule MyModule do
  @doc "Hello world"
  @file "hello.ex"
  def hello do
    "world"
  end
end

`@moduledoc`

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

defmodule MyModule do
  @moduledoc """
  A very useful module.
  """
  @moduledoc authors: ["Alice", "Bob"]
end

Принимает строку (часто heredoc) или false , где @moduledoc false сделает модуль невидимым для инструментов извлечения документации, таких как ExDoc.

Аналогично @doc также принимает список ключевых слов для предоставления метаданных о модуле. Для получения более подробной информации см. документацию @doc выше.

`@on_definition`

Обработчик, который будет вызван при определении каждой функции или макроса в текущем модуле. Полезно при аннотировании функций.

Принимает модуль или {module, function_name} кортеж. См. раздел «Обработчики компиляции» ниже.

`@on_load`

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

Принимает имя функции (как атом) функции в текущем модуле или {function_name, 0} кортеж, где function_name - имя функции в текущем модуле. Функция должна быть публичной и иметь арность 0 (без аргументов). Если функция не возвращает :ok , загрузка модуля будет прервана. Например:

defmodule MyModule do
  @on_load :load_check

  def load_check do
    if some_condition() do
      :ok
    else
      :abort
    end
  end

  def some_condition do
    false
  end
end

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

`@vsn`

Укажите версию модуля. Принимает любое допустимое значение Elixir, например:

defmodule MyModule do
  @vsn "1.0"
end

Атрибуты типов

Следующие атрибуты являются частью типов и также встроенными в Elixir:

@type - определяет тип, используемый в @spec
@typep - определяет закрытый тип, используемый в @spec
@opaque - определяет неявный тип, используемый в @spec
@spec - предоставляет спецификацию для функции
@callback - предоставляет спецификацию для обратного вызова поведения
@macrocallback - предоставляет спецификацию для обратного вызова макроповедения
@optional_callbacks - указывает, какие обратные вызовы поведения и макроповедения являются необязательными
@impl - объявляет реализацию функции обратного вызова или макроса

Пользовательские атрибуты

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

defmodule MyModule do
  @custom_attr [some: "stuff"]
end

Для более расширенных параметров, доступных при определении пользовательских атрибутов, см. register_attribute/3.

Обработчики компиляции

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

`@after_compile`

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

Принимает модуль или {module, function_name} кортеж. Функция должна принимать два аргумента: среду модуля и его байткод. Если предоставлен только модуль, функция предполагается __after_compile__/2.

Обратные вызовы, зарегистрированные первыми, будут выполнены последними.

Пример

defmodule MyModule do
  @after_compile __MODULE__

  def __after_compile__(env, _bytecode) do
    IO.inspect(env)
  end
end

`@before_compile`

Обработчик, который вызывается перед компиляцией модуля.

Принимает модуль или кортеж {module, function_or_macro_name}. Функция/макрос должны принимать один аргумент: среду модуля. Если это макрос, его возвращаемое значение будет вставлено в конец определения модуля перед началом компиляции.

Когда предоставляется только модуль, функция/макрос предполагается __before_compile__/1.

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

Примечание: в отличие от @after_compile, функция/макрос обработчика должен быть размещен в отдельном модуле (потому что когда вызывается обработчик, текущий модуль еще не существует).

Пример

defmodule A do
  defmacro __before_compile__(_env) do
    quote do
      def hello, do: "world"
    end
  end
end

defmodule B do
  @before_compile A
end

B.hello()
#=> "world"

`@on_definition`

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

Принимает модуль или кортеж {module, function_name}. Функция должна принимать 6 аргументов:

среда модуля
тип функции/макроса: :def, :defp, :defmacro, или :defmacrop
имя функции/макроса
список цитируемых аргументов
список цитируемых условий
цитируемое тело функции

Обратите внимание, что обработчик получает цитируемые аргументы, и он вызывается до того, как функция хранится в модуле. Поэтому Module.defines?/2 вернет false для первой части каждой функции.

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

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

Когда предоставляется только модуль, функция предполагается __on_definition__/6.

Пример

defmodule Hooks do
  def on_def(_env, kind, name, args, guards, body) do
    IO.puts("Defining #{kind} named #{name} with args:")
    IO.inspect(args)
    IO.puts("and guards")
    IO.inspect(guards)
    IO.puts("and body")
    IO.puts(Macro.to_string(body))
  end
end

defmodule MyModule do
  @on_definition {Hooks, :on_def}

  def hello(arg) when is_binary(arg) or is_list(arg) do
    "Hello" <> to_string(arg)
  end

  def hello(_) do
    :ok
  end
end

Опции компиляции

Атрибут @compile принимает различные опции, используемые как компиляторами Elixir, так и Erlang. Некоторые из распространённых случаев использования описаны ниже:

@compile :debug_info - включает :debug_info независимо от соответствующей настройки в Code.compiler_options/1
@compile {:debug_info, false} - отключает :debug_info независимо от соответствующей настройки в Code.compiler_options/1
@compile {:inline, some_fun: 2, other_fun: 3} - встраивает заданные пары имя/арность. Встраивание применяется локально, вызовы из другого модуля не затрагиваются этой опцией
@compile {:autoload, false} - отключает автоматическую загрузку модулей после компиляции. Вместо этого модуль будет загружен после его отправки в

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

Сводка

Функции

concat(список): Конкатенирует список псевдонимов и возвращает новый псевдоним.
concat(левый, правый): Конкатенирует два псевдонима и возвращает новый псевдоним.
create(модуль, цитируемое, opts): Создаёт модуль с заданным именем, определённый заданными цитируемыми выражениями.
defines?(модуль, кортеж): Проверяет, определяет ли модуль заданную функцию или макрос.
defines?(модуль, кортеж, def_kind): Проверяет, определяет ли модуль функцию или макрос заданного kind.
defines_type?(модуль, определение): Проверяет, определяет ли текущий модуль заданный тип (приватный, неявный или нет).
definitions_in(модуль): Возвращает все функции, определенные в module.
definitions_in(модуль, def_kind): Возвращает все функции, определённые в module, в соответствии с его типом.
delete_attribute(модуль, ключ): Удаляет атрибут модуля, соответствующий заданному ключу.
eval_quoted(модуль_или_среда, цитируемое, binding \\ [], opts \\ []): Вычисляет цитируемое содержимое в контексте данного модуля.
get_attribute(модуль, ключ): Получает заданный атрибут из модуля.
make_overridable(модуль, кортежи): Делает заданные функции в module переопределяемыми.
open?(модуль): Проверяет, открыт ли модуль.
overridable?(модуль, кортеж): Возвращает true если tuple в module помечен как переопределяемый.
put_attribute(модуль, ключ, значение): Добавляет атрибут модуля с key и value в указанный module.
register_attribute(модуль, атрибут, опции): Регистрирует атрибут.
safe_concat(список): Конкатенирует список псевдонимов и возвращает новый псевдоним только в том случае, если псевдоним уже был сохранён.
safe_concat(левый, правый): Конкатенирует два псевдонима и возвращает новый псевдоним только в том случае, если псевдоним уже был сохранён.
spec_to_callback(модуль, определение): Преобразует заданный спецификацию в обработчик.
split(модуль): Разделяет заданное имя модуля на двоичные части.

Обработчики

__info__(arg1): Предоставляет информацию о времени выполнения о функциях и макросах, определённых модулем, и т. д.

Функции

concat(список)

concat([binary() | atom()]) :: atom()

Конкатенирует список псевдонимов и возвращает новый псевдоним.

Примеры

iex> Module.concat([Foo, Bar])
Foo.Bar

iex> Module.concat([Foo, "Bar"])
Foo.Bar

concat(левый, правый)

concat(binary() | atom(), binary() | atom()) :: atom()

Конкатенирует два псевдонима и возвращает новый псевдоним.

Примеры

iex> Module.concat(Foo, Bar)
Foo.Bar

iex> Module.concat(Foo, "Bar")
Foo.Bar

create(модуль, цитируемое, opts)

create(module(), Macro.t(), Macro.Env.t() | keyword()) ::
  {:module, module(), binary(), term()}

Создаёт модуль с заданным именем, определённый заданными цитируемыми выражениями.

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

Возвращает кортеж структуры {:module, module, binary, term}, где module - имя модуля, binary - байткод модуля, а term - результат последнего выражения в quoted.

Аналогично Kernel.defmodule/2, двоичные данные будут записаны на диск только как файл .beam если Module.create/3 вызывается в файле, который в данный момент компилируется.

Примеры

contents =
  quote do
    def world, do: true
  end

Module.create(Hello, contents, Macro.Env.location(__ENV__))

Hello.world()
#=> true

Отличия от `defmodule`

Module.create/3 работает аналогично Kernel.defmodule/2 и возвращает те же результаты. Хотя можно также использовать defmodule для динамического определения модулей, эта функция предпочтительнее, когда тело модуля задано цитируемым выражением.

Ещё одно важное различие заключается в том, что Module.create/3 позволяет управлять переменными среды, используемыми при определении модуля, в то время как Kernel.defmodule/2 автоматически использует среду, в которой он вызван.

defines?(модуль, кортеж)

defines?(module(), definition()) :: boolean()

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

Используйте defines?/3 для проверки на определённый тип.

Эта функция может использоваться только для модулей, которые ещё не скомпилированы. Используйте Kernel.function_exported?/3 для проверки скомпилированных модулей.

Примеры

defmodule Example do
  Module.defines?(__MODULE__, {:version, 0}) #=> false
  def version, do: 1
  Module.defines?(__MODULE__, {:version, 0}) #=> true
end

defines?(модуль, кортеж, def_kind)

defines?(module(), definition(), def_kind()) :: boolean()

Проверяет, определяет ли модуль функцию или макрос заданного типа kind.

kind может быть любым из :def, :defp, :defmacro, или :defmacrop.

Примеры

defmodule Example do
  Module.defines?(__MODULE__, {:version, 0}, :def) #=> false
  def version, do: 1
  Module.defines?(__MODULE__, {:version, 0}, :def) #=> true
end

defines_type?(модуль, определение)

(с 1.7.0)

defines_type?(module(), definition()) :: boolean()

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

Эта функция доступна только для модулей, которые компилируются.

definitions_in(module)

definitions_in(module()) :: [definition()]

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

Примеры

defmodule Example do
  def version, do: 1
  Module.definitions_in(__MODULE__) #=> [{:version, 0}]
end

definitions_in(module, def_kind)

definitions_in(module(), def_kind()) :: [definition()]

Возвращает все функции, определённые в module, в соответствии с их типом.

Примеры

defmodule Example do
  def version, do: 1
  Module.definitions_in(__MODULE__, :def)  #=> [{:version, 0}]
  Module.definitions_in(__MODULE__, :defp) #=> []
end

delete_attribute(module, key)

delete_attribute(module(), atom()) :: term()

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

Возвращает значение удалённого атрибута (или nil , если ничего не было установлено).

Примеры

defmodule MyModule do
  Module.put_attribute(__MODULE__, :custom_threshold_for_lib, 10)
  Module.delete_attribute(__MODULE__, :custom_threshold_for_lib)
end

eval_quoted(module_or_env, quoted, binding \\ [], opts \\ [])

eval_quoted(
  module() | Macro.Env.t(),
  Macro.t(),
  list(),
  keyword() | Macro.Env.t()
) :: term()

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

В качестве аргумента также может быть передан список опций среды. Подробнее см. Code.eval_string/3.

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

Примеры

defmodule Foo do
  contents =
    quote do
      def sum(a, b), do: a + b
    end

  Module.eval_quoted(__MODULE__, contents)
end

Foo.sum(1, 2)
#=> 3

Для удобства вы можете передать любую структуру Macro.Env, такую как __ENV__/0, в качестве первого аргумента или как опции. Модуль и все опции будут автоматически извлечены из среды:

defmodule Foo do
  contents =
    quote do
      def sum(a, b), do: a + b
    end

  Module.eval_quoted(__ENV__, contents)
end

Foo.sum(1, 2)
#=> 3

Обратите внимание, что если вы передаёте структуру Macro.Env в качестве первого аргумента, а также opts, они будут объединены с opts, при этом приоритет будет у последних.

get_attribute(module, key)

get_attribute(module(), atom()) :: term()

Получает заданный атрибут из модуля.

Если атрибут был помечен accumulate с помощью Module.register_attribute/3, всегда возвращается список. nil возвращается, если атрибут не был помечен accumulate и не был установлен ни на какое значение.

Макрос @ компилируется в вызов этой функции. Например, следующий код:

@foo

Расширяется примерно до:

Module.get_attribute(__MODULE__, :foo)

Примеры

defmodule Foo do
  Module.put_attribute(__MODULE__, :value, 1)
  Module.get_attribute(__MODULE__, :value) #=> 1

  Module.register_attribute(__MODULE__, :value, accumulate: true)
  Module.put_attribute(__MODULE__, :value, 1)
  Module.get_attribute(__MODULE__, :value) #=> [1]
end

make_overridable(module, tuples)

make_overridable(module(), [definition()]) :: :ok

make_overridable(module(), module()) :: :ok

Делает заданные функции в module переопределяемыми.

Переопределяемая функция определяется лениво, что позволяет разработчику её настроить. Подробнее см. Kernel.defoverridable/1.

open?(module)

open?(module()) :: boolean()

Проверяет, открыт ли модуль.

Модуль считается «открытым», если он в настоящее время определяется, и его атрибуты и функции могут быть изменены.

overridable?(module, tuple)

overridable?(module(), definition()) :: boolean()

Возвращает true , если tuple в module помечен как переопределяемый.

put_attribute(module, key, value)

put_attribute(module(), atom(), term()) :: :ok

Устанавливает атрибут модуля с key и value в заданном module.

Примеры

defmodule MyModule do
  Module.put_attribute(__MODULE__, :custom_threshold_for_lib, 10)
end

register_attribute(module, attribute, options)

register_attribute(module(), atom(), accumulate: boolean(), persist: boolean()) ::
  :ok

Регистрирует атрибут.

Регистрация атрибута позволяет разработчику настроить то, как Elixir будет хранить и накапливать значения атрибутов.

Опции

При регистрации атрибута можно указать две опции:

:accumulate — несколько вызовов того же атрибута будут накапливаться вместо перезаписи предыдущего. Новые атрибуты всегда добавляются в начало накопленного списка.
:persist — атрибут будет сохранён в формате Erlang Abstract Format. Полезно при взаимодействии с библиотеками Erlang.

По умолчанию обе опции false.

Примеры

defmodule MyModule do
  Module.register_attribute(__MODULE__, :custom_threshold_for_lib, accumulate: true)

  @custom_threshold_for_lib 10
  @custom_threshold_for_lib 20
  @custom_threshold_for_lib #=> [20, 10]
end

safe_concat(list)

safe_concat([binary() | atom()]) :: atom()

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

Если псевдоним ещё не ссылался, происходит ошибка ArgumentError. Обрабатываются списки символов, двоичные данные и атомы.

Примеры

iex> Module.safe_concat([Module, Unknown])
** (ArgumentError) argument error

iex> Module.safe_concat([List, Chars])
List.Chars

safe_concat(left, right)

safe_concat(binary() | atom(), binary() | atom()) :: atom()

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

Примеры

iex> Module.safe_concat(Module, Unknown)
** (ArgumentError) argument error

iex> Module.safe_concat(List, Chars)
List.Chars

spec_to_callback(module, definition)

(since 1.7.0)

spec_to_callback(module(), definition()) :: boolean()

Преобразует заданный спецификацию в обратный вызов.

Возвращает true , если такая спецификация существует и была преобразована в обратный вызов.

split(module)

split(module() | String.t()) :: [String.t(), ...]

Разделяет заданное имя модуля на бинарные части.

module должен быть модулем Elixir, так как split/1 не будет работать с модулями в стиле Erlang (например, split(:lists) вызывает ошибку).

split/1 также поддерживает разделение строкового представления модулей Elixir (т.е. результат вызова Atom.to_string/1 с именем модуля).

Примеры

iex> Module.split(Very.Long.Module.Name.And.Even.Longer)
["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
iex> Module.split("Elixir.String.Chars")
["String", "Chars"]

Обратные вызовы

info(arg1)

__info__(:functions | :macros | :module | :md5 | :compile | :attributes) ::
  term()

Предоставляет информацию о времени выполнения о функциях и макросах, определённых модулем и т.д.

Каждый модуль получает функцию __info__/1 при компиляции. Функция принимает один из следующих атомов:

:functions — список ключевых слов общедоступных функций вместе с их арностью
:macros — список ключевых слов общедоступных макросов вместе с их арностью
:module — имя атома модуля
:md5 — MD5 модуля
:compile — список с метаданными компилятора
:attributes — список со всеми сохранёнными атрибутами

Модуль behaviour

Атрибуты модуля

@after_compile

@before_compile

@behaviour

@impl

@compile

@deprecated

@doc и @typedoc

@dialyzer

@external_resource

@file

@moduledoc

@on_definition

@on_load

@vsn

Атрибуты типов

Пользовательские атрибуты

Обработчики компиляции

@after_compile

Пример

@before_compile

Пример

@on_definition

Пример

Опции компиляции

Сводка

Функции

Обработчики

Функции

concat(список)

Примеры

concat(левый, правый)

Примеры

create(модуль, цитируемое, opts)

Примеры

Отличия от defmodule

defines?(модуль, кортеж)

Примеры

defines?(модуль, кортеж, def_kind)

Примеры

defines_type?(модуль, определение)

definitions_in(module)

Примеры

definitions_in(module, def_kind)

Примеры

delete_attribute(module, key)

Примеры

eval_quoted(module_or_env, quoted, binding \\ [], opts \\ [])

Примеры

get_attribute(module, key)

Примеры

make_overridable(module, tuples)

open?(module)

overridable?(module, tuple)

put_attribute(module, key, value)

Примеры

register_attribute(module, attribute, options)

Опции

Примеры

safe_concat(list)

Примеры

safe_concat(left, right)

Примеры

spec_to_callback(module, definition)

split(module)

Примеры

Обратные вызовы

__info__(arg1)

`@after_compile`

`@before_compile`

`@behaviour`

`@impl`

`@compile`

`@deprecated`

`@doc` и `@typedoc`

`@dialyzer`

`@external_resource`

`@file`

`@moduledoc`

`@on_definition`

`@on_load`

`@vsn`

`@after_compile`

`@before_compile`

`@on_definition`

Отличия от `defmodule`

info(arg1)