4.3 使用协议的多态性

多态性是在运行时根据输入数据的性质决定执行哪个代码。在 Elixir 中，基本的（但不是唯一的）实现方式是使用称为协议的语言特性。

在讨论协议之前，让我们看看它们的实际应用。您已经见过多态代码。例如，整个 Enum 模块是通用代码，可以在任何可枚举的对象上工作，以下片段说明了这一点：

Enum.each([1, 2, 3], &IO.inspect/1)
Enum.each(1..3, &IO.inspect/1)
Enum.each(%{a: 1, b: 2}, &IO.inspect/1)

注意你如何使用相同的 Enum.each/2 函数，发送不同的数据结构：列表、范围和映射。 Enum.each/2 如何知道如何遍历每个结构？它不知道。 Enum.each/2 中的代码是通用的，并依赖于一个契约。这个契约称为协议，必须为每个你希望与 Enum 函数一起使用的数据类型实现。接下来，让我们学习如何定义和使用协议。

4.3.1 协议基础

协议是一个模块，在其中你声明函数而不实现它们。可以将其视为面向对象接口的粗略等价物。通用逻辑依赖于协议并调用其函数。然后，你可以为不同的数据类型提供协议的具体实现。

让我们看一个例子。协议 String.Chars 是由 Elixir 标准库提供的，用于将数据转换为二进制字符串。以下是该协议在 Elixir 源代码中的定义：

defprotocol String.Chars do    
  def to_string(term)          
end

协议的定义

协议功能声明

这类似于模块定义，显著的区别在于函数被声明但未实现。

注意函数的第一个参数（ term ）。在运行时，这个参数的类型决定了调用的实现。让我们看看这个实际应用。Elixir 已经为原子、数字和一些其他数据类型实现了该协议，因此您可以发出以下调用：

iex(1)> String.Chars.to_string(1)
"1"
 
iex(2)> String.Chars.to_string(:an_atom)
"an_atom"

如果未针对给定数据类型实现协议，则会引发错误：

iex(3)> String.Chars.to_string(TodoList.new())
** (Protocol.UndefinedError) protocol String.Chars not implemented

通常，您不需要直接调用协议函数。更常见的是，有通用代码依赖于该协议。在 String.Chars 的情况下，这是自动导入的函数 Kernel.to_string/1 ：

iex(4)> to_string(1)
"1"
 
iex(5)> to_string(:an_atom)
"an_atom"
 
iex(6)> to_string(TodoList.new())
** (Protocol.UndefinedError) protocol String.Chars not implemented

如您所见， to_string/1 的行为与 String.Chars.to_string/1 完全相同。这是因为 Kernel.to_string/1 委托给 String.Chars 实现。

此外，您可以将任何实现 String.Chars 的内容发送到 IO.puts/1 ：

iex(7)> IO.puts(1)
1
 
iex(8)> IO.puts(:an_atom)
an_atom
 
iex(9)> IO.puts(TodoList.new())
** (Protocol.UndefinedError) protocol String.Chars not implemented

如您所见， TodoList 的一个实例无法打印，因为对应类型未实现 String.Chars 。

4.3.2 实施协议

如何为特定类型实现协议？让我们再次参考 Elixir 源代码。以下代码片段为整数实现了 String.Chars ：

defimpl String.Chars, for: Integer do
  def to_string(term) do
    Integer.to_string(term)
  end
end

您通过调用 defimpl 宏开始实现。然后，您指定要实现的协议和相应的数据类型。最后， do/end 块包含每个协议函数的实现。在示例中，实施委托给现有的标准库函数 Integer.to_string/1 。

for: Type 部分值得一些解释。类型是一个原子，可以是以下别名中的任何一个： Tuple 、 Atom 、 List 、 Map 、 BitString 、 Integer 、 Float 、 Function 、 PID 、 Port 或 Reference 。这些值对应于内置的 Elixir 类型。

此外，允许使用别名 Any ，这使得可以指定一个后备实现。如果某个类型没有定义协议，将会引发错误，除非在协议定义中指定了对 Any 的后备，并且存在 Any 实现。有关详细信息，请参阅协议文档 (https://hexdocs.pm/elixir/Protocol.xhtml)。

最后，最重要的是，类型可以是任何其他任意别名（但不能是常规的简单原子）：

defimpl String.Chars, for: SomeAlias do
  ...
end

此实现将在协议函数的第一个参数是相应模块中定义的结构时被调用。例如，您可以如下实现 String.Chars 对 TodoList 的支持：

iex(1)> defimpl String.Chars, for: TodoList do
          def to_string(_) do
            "#TodoList"
          end
        end
 

现在，您可以将待办事项列表实例传递给 IO.puts/1 ：

iex(2)> IO.puts(TodoList.new())
#TodoList

重要的是要注意，协议实现不需要成为任何模块的一部分。这具有强大的影响：您可以为一个类型实现协议，即使您无法修改该类型的源代码。您可以将协议实现放置在您自己代码的任何位置，运行时将能够利用它。

4.3.3 内置协议

Elixir 提供了一些预定义的协议。最好查阅在线文档以获取完整参考（https://hexdocs.pm/elixir），但我们还是提到一些最重要的协议。

您已经看过 String.Chars ，它指定了将数据转换为二进制字符串的合同。还有 List.Chars 协议，它将输入数据转换为字符字符串（字符列表）。

如果您想控制结构在调试输出中的打印方式（通过 inspect 函数），您可以实现 Inspect 协议。

可以说，最重要的协议是 Enumerable 。通过实现它，您可以使您的数据结构可枚举。这意味着您可以免费使用 Enum 和 Stream 模块中的所有功能！这可能是协议有用性的最佳示范。 Enum 和 Stream 都是通用模块，提供许多有用的功能，只要您实现了 Enumerable 协议，它们就可以在您的自定义数据结构上工作。

与枚举密切相关的是 Collectable 协议。回想一下第 3 章，可收集结构是指可以反复添加元素的结构。可收集结构可以与推导式一起使用以收集结果，或与 Enum.into/2 一起使用以将一个结构（可枚举）中的元素转移到另一个结构（可收集）。

当然，您可以定义自己的协议并将其实现为任何可用的数据结构（您自己的或他人的）。有关更多信息，请参见 Kernel.defprotocol/2 文档。

可收集的待办事项列表

让我们看一个更复杂的例子。你将使你的待办事项列表可收集，以便将其用作理解目标。这是一个稍微高级的例子，所以如果你第一次没有理解每个细节也不用担心。

要使抽象可收集，您必须实现相应的协议：

defimpl Collectable, for: TodoList do                   
  def into(original) do                                 
    {original, &into_callback/2}                        
  end
 
  defp into_callback(todo_list, {:cont, entry}) do      
    TodoList.add_entry(todo_list, entry)                
  end                                                   
                                                        
  defp into_callback(todo_list, :done), do: todo_list   
  defp into_callback(_todo_list, :halt), do: :ok        
end

返回 appender lambda

附加器实现

导出的函数 into/1 被通用代码（例如，推导式）调用。在这里，您提供返回附加器 lambda 的实现。然后，通用代码会重复调用此附加器 lambda，将每个元素附加到您的数据结构中。

附加函数接收一个待办事项列表和一个指令提示。如果收到 {:cont, entry} ，则必须添加一个新条目。如果收到 :done ，则返回列表，此时包含所有附加元素。最后， :halt 表示操作已被取消，返回值被忽略。

让我们看看这个如何运作。将之前的代码复制并粘贴到终端中，然后尝试以下操作：

iex(1)> entries = [
          %{date: ~D[2023-12-19], title: "Dentist"},
          %{date: ~D[2023-12-20], title: "Shopping"},
          %{date: ~D[2023-12-19], title: "Movies"}
        ]
 
iex(2)> Enum.into(entries, TodoList.new())    
%TodoList{...}

收集到待办事项列表

通过实现 Collectable 协议，您实际上将 TodoList 抽象适配到任何依赖该协议的通用代码，例如 Enum.into/2 或 for 理解。

摘要

• 模块用于创建抽象。模块的函数创建、操作和查询数据。客户端可以检查整个结构，但不应依赖其形状。
• 地图可以用来将不同领域组合在一个结构中。
• 结构体是一种特殊的映射，允许您定义与模块相关的数据抽象。
• 多态可以通过协议实现。协议定义了一个由泛型逻辑使用的接口。然后，您可以为数据类型提供特定的协议实现。