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

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

Примеры

В 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 (см. ниже)

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

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

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

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

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/2 вы можете использовать @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 - то же самое, что и выше, но вызывает ошибку, если реализация не найдена

Например, для протокола 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` - returns the module responsible for the data structure of the protocol implementation

* `:protocol` - returns the protocol module for which this implementation is provided

Например, модуль, реализующий протокол 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

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

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