Модуль

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

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

После компиляции модуля использование многих функций этого модуля вызовет ошибки, так как они не предназначены для проверки данных во время выполнения. Большинство данных во время выполнения можно проверить через функцию __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 , пример выше можно переписать как:

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

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

  @impl Baz # will warn if Baz does not specify a callback named baz/0
  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.

END_OF_DOCUMENT_MARKER

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

Примечание: в отличие от @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(модуль_или_среда, цитированное, привязка \\ [], 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(модуль): Разделяет заданное имя модуля на бинарные части

Функции

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}, :defp #=> false
  def version, do: 1
  Module.defines? __MODULE__, {:version, 0}, :defp #=> false
end

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

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

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

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

definitions_in(модуль)

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

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

Примеры

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

definitions_in(модуль, 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)
  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)
  Module.eval_quoted __ENV__, contents
end

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

Обратите внимание, что если вы передадите структуру Macro.Env в качестве первого аргумента, а также передадите opts, они будут объединены с 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(), module()) :: :ok

make_overridable(module(), [definition()]) :: :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, persist: false

  @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"]

Модуль

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

@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?(модуль, определение) (с 1.7.0)

definitions_in(модуль)

Примеры

definitions_in(модуль, 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) (since 1.7.0)

split(module)

Примеры

`@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`