协议

  1. 协议与结构体
  2. 执行Any
    1. 派生
    2. 回退到Any
  3. 内置协议
  4. 协议巩固

协议是Elixir中用于达到多态性的一个机制.任何数据类型只要实现了协议,就可以基于协议被调度.让我们来看一个例子.

在Elixir中,只有falsenil为假.任何其他东西都为真.对应用来说,设定一个返回布尔值的blank?协议来判断其它数据类型是否为空也许十分重要.事实上,一个空的列表或一个空的二进制数会被认为是空的.

我们能够这样定义协议:

  1. defprotocol Blank do
  2. @doc "Returns true if data is considered blank/empty"
  3. def blank?(data)
  4. end

该协议需要一个名为blank?的函数,它接受一个参数.我们可以为其它Elixir数据类型实现这个协议:

  1. # 整数不可能为空白
  2. defimpl Blank, for: Integer do
  3. def blank?(_), do: false
  4. end
  5. # 空的列表是空白
  6. defimpl Blank, for: List do
  7. def blank?([]), do: true
  8. def blank?(_), do: false
  9. end
  10. # 空的映射是空白
  11. defimpl Blank, for: Map do
  12. # 记住我们不能用%{}来模式匹配
  13. # 它能匹配所有映射.但我们可以判断映射大小是否
  14. # 为零(而且计算大小是一个快速操作).
  15. def blank?(map), do: map_size(map) == 0
  16. end
  17. # 原子false和nil是空白
  18. defimpl Blank, for: Atom do
  19. def blank?(false), do: true
  20. def blank?(nil), do: true
  21. def blank?(_), do: false
  22. end

我们为所有原始数据类型都这样做了.这些类型有:

  1. Atom
  2. BitString
  3. Float
  4. Function
  5. Integer
  6. List
  7. Map
  8. PID
  9. Port
  10. Reference
  11. Tuple

协议和实现都已经定义好,我们可以调用它了:

  1. iex> Blank.blank?(0)
  2. false
  3. iex> Blank.blank?([])
  4. true
  5. iex> Blank.blank?([1, 2, 3])
  6. false

传递了一个协议没有实现的数据类型将会抛出一个错误:

  1. iex> Blank.blank?("hello")
  2. ** (Protocol.UndefinedError) protocol Blank not implemented for "hello"

协议与结构体

当同时使用协议与结构体时,Elixir的可扩展性就显示出来了.

在之前的章节,我们已经知道尽管结构体也是映射,但他们不和映射共享协议实现.让我们来定义一个和那一章中一样的User结构体:

  1. iex> defmodule User do
  2. ...> defstruct name: "john", age: 27
  3. ...> end
  4. {:module, User,
  5. <<70, 79, 82, ...>>, {:__struct__, 0}}

然后检查:

  1. iex> Blank.blank?(%{})
  2. true
  3. iex> Blank.blank?(%User{})
  4. ** (Protocol.UndefinedError) protocol Blank not implemented for %User{age: 27, name: "john"}

结构体需要他们自己的协议实现:

  1. defimpl Blank, for: User do
  2. def blank?(_), do: false
  3. end

如果需要的话,你可以自己定义User的空白判断.你还可以使用结构体来构建更强大的数据类型,例如队列,然后为其实现所有相关的协议,例如EnumerableBlank.

实现Any

手动实现对多有类型的协议是很繁琐和重复的.Elixir提供了两个选项:我们给自己的类型可以明确推导出协议的实现,或是为所有类型自动实现协议.无论哪种,我们都需要为Any实现协议.

派生

Elixir允许我们基于Any的实现来派生一个协议实现.让我们先实现Any:

  1. defimpl Blank, for: Any do
  2. def blank?(_), do: false
  3. end

现在,当定义结构体时,我们能够精确地派生Blank协议的实现.让我们创造另一个结构体,名为DeriveUser:

  1. defmodule DeriveUser do
  2. @derive Blank
  3. defstruct name: "john", age: 27
  4. end

当派生的时候,Elixir会基于Any的实现来为DeriveUser实现Blank协议.注意这个行为是选择性加入:注意结构体的协议只可能是明确实现的或派生而来的.

回退到Any

当一个实现无法找到时,@derive的替代方法是明确地告知协议回退到Any.通过在协议定义中将@fallback_to_any设置为true:

  1. defprotocol Blank do
  2. @fallback_to_any true
  3. def blank?(data)
  4. end

假设我们已经像之前那样实现了Any:

  1. defimpl Blank, for: Any do
  2. def blank?(_), do: false
  3. end

现在所有没有实现Blank协议的数据类型(包括结构体)都会被认为是非空白的.与@derive相反,回退到Any是选择性退出的:所有数据都得到了一个预置的行为,除非它们提供了自己的协议实现.那种技术更好取决于使用场景,但Elixir开发者更趋向于使用显性定义,你能看到许多库使用@derive.

内置协议

Elixir装载了许多内置协议.在上一章,我们讨论了Enum模块,任何数据结构只要实现了Enumerable协议就可以使用模块中提供的函数:

  1. iex> Enum.map [1, 2, 3], fn(x) -> x * 2 end
  2. [2, 4, 6]
  3. iex> Enum.reduce 1..3, 0, fn(x, acc) -> x + acc end
  4. 6

另一个有用的例子是String.Chars协议,它指定了如何将字符转化为字符串.它暴露于to_string函数:

  1. iex> to_string :hello
  2. "hello"

注意Elixir中的字符串插值调用了to_string函数:

  1. iex> "age: #{25}"
  2. "age: 25"

上述片段能够工作是因为数字实现了String.Chars协议.如果传送一个元组,就会出现错误:

  1. iex> tuple = {1, 2, 3}
  2. {1, 2, 3}
  3. iex> "tuple: #{tuple}"
  4. ** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3}

当需要”打印”一个更复杂的数据结构时,可以简单地使用基于Inspect协议的inspect函数:

  1. iex> "tuple: #{inspect tuple}"
  2. "tuple: {1, 2, 3}"

Inspect协议的作用是约定如何将任何数据结构转化为可读的文本表示.这就是IEx用来打印结果的工具:

  1. iex> {1, 2, 3}
  2. {1, 2, 3}
  3. iex> %User{}
  4. %User{name: "john", age: 27}

记住,处于方便,如果被检查后的值以#开头,这表明着该数据结构使用了非法的Elixir语法.这意味着检查协议是不可逆的,因为信息有可能在中途丢失:

  1. iex> inspect &(&1+2)
  2. "#Function<6.71889879/1 in :erl_eval.expr/5>"

Elixir中还有许多协议,但以上是最普遍的.

协议巩固

当使用Mix构建工具处理Elixir项目时,你可能会看到如下输出:

  1. Consolidated String.Chars
  2. Consolidated Collectable
  3. Consolidated List.Chars
  4. Consolidated IEx.Info
  5. Consolidated Enumerable
  6. Consolidated Inspect

这是Elixir中装载的所有协议,它们都被巩固了.由于一个协议可以被调度到任何数据类型,该协议必须检查每一个调用中给定类型的实现是否已经存在.这可能很复杂.

然而,我们的项目在使用类似Mix的工具编译过之后,就可以知道所有定义了的模块,包括协议和它们的实现.这样,协议就可以被巩固成一个非常简单快速的调度模块.

从Elixir v1.2开始,所有项目会自动执行协议巩固.在Mix和OPT入门中我们将会构建自己的项目.