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

Протокол определяет API, который должен быть реализован его имплементациями. Протокол определяется с помощью Kernel.defprotocol/2, а его реализации — с помощью Kernel.defimpl/3.

Реальный пример

В Elixir для подсчета элементов в структуре данных используются два существительных: length и size. length означает, что информация должна быть вычислена. Например, length(list) необходимо пройти по всему списку, чтобы вычислить его длину. С другой стороны, tuple_size(tuple) и byte_size(binary) не зависят от размера кортежа и бинарника, так как информация о размере предварительно вычислена в структуре данных.

Хотя в Elixir существуют специфические функции, такие как tuple_size, binary_size и map_size, иногда требуется получить размер структуры данных независимо от ее типа. В Elixir можно писать полиморфный код, то есть код, работающий с различными формами/типами, используя протоколы. Протокол размера может быть реализован следующим образом:

defprotocol Size do
  @doc "Calculates the size (and not the length!) of a data structure"
  def size(data)
end

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

defimpl Size, for: BitString do
  def size(binary), do: byte_size(binary)
end

defimpl Size, for: Map do
  def size(map), do: map_size(map)
end

defimpl Size, for: Tuple do
  def size(tuple), do: tuple_size(tuple)
end

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

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

Можно реализовать протоколы для всех типов Elixir:

• Структуры (см. раздел «Протоколы и структуры» ниже)
• Tuple
• Atom
• List
• BitString
• Integer
• Float
• Function
• PID
• Map
• Port
• Reference
• Any (см. раздел «Обработка по умолчанию Any» ниже)

Протоколы и структуры

Настоящая польза протоколов проявляется при их комбинировании со структурами. Например, в Elixir поставляется много типов данных, реализованных в виде структур, например, MapSet. Мы также можем реализовать протокол Size для этих типов:

defimpl Size, for: MapSet do
  def size(map_set), do: MapSet.size(map_set)
end

При реализации протокола для структуры опцию :for можно опустить, если вызов defimpl/3 находится в модуле, определяющем структуру:

defmodule User do
  defstruct [:email, :name]

  defimpl Size do
    # two fields
    def size(%User{}), do: 2
  end
end

Если реализация протокола для заданного типа не найдена, вызов протокола вызовет исключение, если не настроена обработка по умолчанию Any. Также доступны удобные инструменты для построения реализаций на основе существующих. Смотрите defstruct/1 для получения дополнительной информации о выводе протоколов.

Обработка по умолчанию Any

В некоторых случаях может быть удобно предоставить реализацию по умолчанию для всех типов. Это можно сделать, установив атрибут @fallback_to_any в true в определении протокола:

defprotocol Size do
  @fallback_to_any true
  def size(data)
end

Теперь протокол Size может быть реализован для Any:

defimpl Size, for: Any do
  def size(_), do: 0
end

Хотя приведенная выше реализация, вероятно, не является разумной. Например, не имеет смысла говорить, что PID или целое число имеют размер 0. Это одна из причин, почему @fallback_to_any — это поведенческая опция. Для большинства протоколов возбуждение ошибки при отсутствии реализации протокола — это правильное поведение.

Несколько реализаций

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

defprotocol Reversible do
  def reverse(term)
end

defimpl Reversible, for: [Map, List] do
  def reverse(term), do: Enum.reverse(term)
end

Внутри defimpl/3 можно использовать @protocol для доступа к реализуемому протоколу и @for для доступа к модулю, для которого он определён.

Типы

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

@spec print_size(Size.t()) :: :ok
def print_size(data) do
  result =
    case Size.size(data) do
      0 -> "data has no items"
      1 -> "data has one item"
      n -> "data has #{n} items"
    end

  IO.puts(result)
end

@spec выше выражает, что все типы, разрешенные для реализации данного протокола, являются допустимыми типами аргументов для данной функции.

Рефлексия

Любой модуль протокола содержит три дополнительные функции:

• __protocol__/1 — возвращает информацию о протоколе. Функция принимает одно из следующих атомов:

  • :consolidated? — возвращает, является ли протокол консолидированным
  • :functions — возвращает список функций протокола и их арности в виде списка ключевых слов
  • :impls — если консолидирован, возвращает {:consolidated, modules} со списком модулей, реализующих протокол, иначе :not_consolidated
  • :module — атомное имя модуля протокола

• impl_for/1 — возвращает модуль, который реализует протокол для данного аргумента, nil в противном случае

• impl_for!/1 — то же самое, что и выше, но вызывает Protocol.UndefinedError, если реализация не найдена

Например, для протокола Enumerable у нас есть:

iex> Enumerable.__protocol__(:functions)
[count: 1, member?: 2, reduce: 3, slice: 1]

iex> Enumerable.impl_for([])
Enumerable.List

iex> Enumerable.impl_for(42)
nil

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

• :for — возвращает модуль, ответственный за структуру данных реализации протокола

• :protocol — возвращает модуль протокола, для которого предоставляется данная реализация

Например, модуль, реализующий протокол Enumerable для списков, является Enumerable.List. Поэтому мы можем вызвать __impl__/1 в этом модуле:

iex(1)> Enumerable.List.__impl__(:for)
List

iex(2)> Enumerable.List.__impl__(:protocol)
Enumerable

Консолидация

Для ускорения диспетчеризации протоколов, когда все реализации протокола известны заранее, обычно после компиляции всего кода Elixir в проекте, Elixir предоставляет функцию консолидации протоколов. Консолидация напрямую связывает протоколы с их реализациями таким образом, что вызов функции из консолидированного протокола эквивалентен вызову двух удалённых функций.

Консолидация протоколов применяется по умолчанию ко всем проектам Mix во время компиляции. Это может быть проблемой во время тестирования. Например, если вы хотите реализовать протокол во время тестирования, реализация не повлияет, так как протокол уже был консолидирован. Одно из возможных решений — включить каталоги компиляции, специфичные для среды тестирования, в ваш mix.exs:

def project do
  ...
  elixirc_paths: elixirc_paths(Mix.env())
  ...
end

defp elixirc_paths(:test), do: ["lib", "test/support"]
defp elixirc_paths(_), do: ["lib"]

Затем вы можете определить реализации, специфичные для среды тестирования, внутри test/support/some_file.ex.

Другой подход заключается в отключении консолидации протоколов во время тестирования в вашем mix.exs:

def project do
  ...
  consolidate_protocols: Mix.env() != :test
  ...
end

Если вы используете Mix.install/2, вы можете сделать это, передав параметр consolidate_protocols:

Mix.install(
  deps,
  consolidate_protocols: false
)

Хотя это не рекомендуется, так как может повлиять на производительность вашего кода.

Наконец, обратите внимание, что все протоколы компилируются с debug_info установленным в true, независимо от опции, установленной компилятором elixirc. Информация отладки используется для консолидации и удаляется после консолидации, если не установлено глобально.