宏

  1. 前言
  2. 我们的第一个宏
  3. 宏的隔离
  4. 环境
  5. 私有宏
  6. 负责任地编写宏

前言

尽管Elixir已竭力为宏提供一个安全的环境,用宏编写干净代码的责任仍然落在了开发者身上.宏比传统的Elixir函数更难编写,而且在不必要的场合使用宏是不好的.所以请负责任地编写宏.

Elixir已经提供了许多数据结构和函数,能够让你以简单可读的风格编写日常代码.宏应当是最后的选择.记住,明显胜过含蓄.清晰的代码胜过简洁的代码.

我们的第一个宏

ELixir中使用defmacro/2来定义宏.

本章,我们将使用文件来代替在IEx中运行样本代码.这是因为代码样本将跨越许多行,将它们全部输入IEx会适得其反.你应当将代码样本保存进macro.exs文件,并使用elixir macros.exs或iex macro.exs来运行.

为了更好地理解宏是如何运作的,让我们创建一个新的模块,在其中实现unless,它的作用与if相反.分别以函数和宏的形式:

  1. defmodule Unless do
  2.   def fun_unless(clause, expression) do
  3.     if(!clause, do: expression)
  4.   end
  6.   defmacro macro_unless(clause, expression) do
  7.     quote do
  8.       if(!unquote(clause), do: unquote(expression))
  9.     end
  10.   end
  11. end

函数接收了参数,并传送给if.然而正如我们在前一章所学过的,宏会接收引用表达式,将它们注入引用,最后返回另一个引用表达式.

让我们用iex运行上面的模块:

  1. $ iex macros.exs

调戏一下那些定义:

  1. iex> require Unless
  2. iex> Unless.macro_unless true, IO.puts "this should never be printed"
  3. nil
  4. iex> Unless.fun_unless true, IO.puts "this should never be printed"
  5. "this should never be printed"
  6. nil

注意,在宏的实现中,句子没有被打印,然而在函数的实现中,句子被打印了.这是因为函数的参数会在调用函数之前被执行.而宏不会执行它们的参数.它们以引用表达式的形式接收参数,之后又将其变形为其它引用表达式.本例中,我们实际上是将unless宏重写成了一个if.

换句话说,当被这样调用时:

  1. Unless.macro_unless true, IO.puts "this should never be printed"

我们的macro_unless宏接收到了:

  1. macro_unless(true, {{:., [], [{:aliases, [], [:IO]}, :puts]}, [], ["this should never be printed"]})

然后返回了一个引用表达式:

  1. {:if, [],
  2.  [{:!, [], [true]},
  3.   [do: {{:., [],
  4.      [{:__aliases__,
  5.        [], [:IO]},
  6.       :puts]}, [], ["this should never be printed"]}]]}

我们可以使用Macro.expand_once/2来验证它:

  1. iex> expr = quote do: Unless.macro_unless(true, IO.puts "this should never be printed")
  2. iex> res  = Macro.expand_once(expr, __ENV__)
  3. iex> IO.puts Macro.to_string(res)
  4. if(!true) do
  5.   IO.puts("this should never be printed")
  6. end
  7. :ok

Macro.expand_once/2接收了引用表达式,并根据当前环境扩展了它.本例中,它扩展/调用了Unless.macro_unless/2宏,并返回了结果.之后我们将返回的引用表达式转换成一个字符串并打印出来(我们将在本章稍后的位置讨论__ENV__).

这就是宏.它们接收引用表达式并将其变形为别的东西.事实上,Elixir中的unless/2是作为宏来实现的:

  1. defmacro unless(clause, options) do
  2.   quote do
  3.     if(!unquote(clause), do: unquote(options))
  4.   end
  5. end

本教程中用到的许多纯Elixir实现的结构都是宏,例如unless/2,defmacro/2,def/2,defprotocol/2等等.这意味着,开发者可以用构建语言的结构来将语言扩展到它们工作的领域.

我们可以定义任何函数和宏,甚至覆盖Elixir中的原本定义.唯一的例外是Elixir特殊形式,它们不是由Elixir实现的,因此不能被覆盖,特殊形式的完整列表可以在Kernel.SpecialForms中找到.

宏的隔离(Macros hygiene)

Elixir的宏有着低决定权.这保证了引用中的变量定义不会与宏被扩展到的语境中的变量定义相冲突.例如:

  1. defmodule Hygiene do
  2.   defmacro no_interference do
  3.     quote do: a = 1
  4.   end
  5. end
  7. defmodule HygieneTest do
  8.   def go do
  9.     require Hygiene
  10.     a = 13
  11.     Hygiene.no_interference
  12.     a
  13.   end
  14. end
  16. HygieneTest.go
  17. # => 13

上述例子中,即使宏注入了a = 1,却没有影响到变量a在函数go中的定义.如果宏想要明确地影响语境,可以使用var!:

  1. defmodule Hygiene do
  2.   defmacro interference do
  3.     quote do: var!(a) = 1
  4.   end
  5. end
  7. defmodule HygieneTest do
  8.   def go do
  9.     require Hygiene
  10.     a = 13
  11.     Hygiene.interference
  12.     a
  13.   end
  14. end
  16. HygieneTest.go
  17. # => 1

因为Elixir使用变量的语境来注解它,所以能够实现变量隔离.例如,一个模块的第三行定义的变量x可以被表示成:

  1. {:x, [line: 3], nil}

然而一个引用变量是这样表示的:

  1. defmodule Sample do
  2.   def quoted do
  3.     quote do: x
  4.   end
  5. end
  7. Sample.quoted #=> {:x, [line: 3], Sample}

注意引用变量的第三个元素是原子Sample,而不是nil,它标记了变量是来自Sample模块的.因此,Elixir认为这两个变量来自不同语境,会分别处理它们.

Elixir也为进口(imports)和别名(aliases)提供了相似的机制.这保证了宏的行为会与它源模块中的定义相同,而不是与宏所扩展到的目标模块相冲突.使用类似var!/2和alias!/2之类的宏可以突破隔离,但是它们必须小心使用,因为这直接改变了用户环境.

有时,变量名会被动态地创建.Macro.var/2可用于定义新变量:

  1. defmodule Sample do
  2.   defmacro initialize_to_char_count(variables) do
  3.     Enum.map variables, fn(name) ->
  4.       var = Macro.var(name, nil)
  5.       length = name |> Atom.to_string |> String.length
  6.       quote do
  7.         unquote(var) = unquote(length)
  8.       end
  9.     end
  10.   end
  12.   def run do
  13.     initialize_to_char_count [:red, :green, :yellow]
  14.     [red, green, yellow]
  15.   end
  16. end
  18. > Sample.run #=> [3, 5, 6]

注意Macro.var/2的第二个变量.在下一节中我们将知道它是所使用的语境,而且能定义隔离.

环境

本章早些时候,我们调用Macro.expand_once/2时,使用了特殊形式__ENV__.

__ENV__返回了一个Macro.Env结构的实例,它包含了编译环境的有用信息,包括当前模块,文件和行,所有定义在当前作用域中的变量,还有imports,requires等等.

  1. iex> __ENV__.module
  2. nil
  3. iex> __ENV__.file
  4. "iex"
  5. iex> __ENV__.requires
  6. [IEx.Helpers, Kernel, Kernel.Typespec]
  7. iex> require Integer
  8. nil
  9. iex> __ENV__.requires
  10. [IEx.Helpers, Integer, Kernel, Kernel.Typespec]

Macro模块中的许多函数都期望一个环境.你可以在Macro模块中找到关于这些函数,以及在Macro.Env的文档中找到关于编译环境的更多信息.

私有宏

Elixir也支持私有宏,使用defmacrop来定义.和私有函数一样,这些宏只能在它的定义模块中使用,而且只在编译时.

很重要的一点是,宏在使用之前定义.没有在调用一个宏之前定义它,将会在运行时抛出一个错误,因为宏不会被扩展,而且将会被转化成函数调用:

  1. iex> defmodule Sample do
  2. ...>  def four, do: two + two
  3. ...>  defmacrop two, do: 2
  4. ...> end
  5. ** (CompileError) iex:2: function two/0 undefined

负责任地编写宏

宏是很强大的结构,Elixir提供了许多机制来确保它们被负责任地使用.

- 宏是隔离的: 定义在宏内的变量默认是不会影响用户代码的.而且,宏语境中的函数调用和别名是不会泄露到用户语境中的.

- 宏具有词典性质: 不可能全局地注入代码或宏.为了使用宏,你需要明确地require或import定义了宏的模块.

- 宏是明确的: 宏不可能在没有明确被导入的情况下运行.例如,一些语言允许开发者在内部完全重写函数,通常是通过语义转换或一些反射机制.在Elixir中,编译时,宏必须在调用者中被明确导入.

- 宏的语言是清晰的: 许多语言为quote和unquote提供了语法捷径.在Elixir中,我们更愿意它们被明确地拼写出来,以便清楚地划出宏定义与它的引用表达式间的界限.

即使有这些保障,开发者仍在负责任地编写宏这件事中扮演重要角色.如果你确信你需要使用宏,记住宏不是你的API.你的宏定义要保持简短,包括它们的引用内容.例如,与其像这样编写宏:

  1. defmodule MyModule do
  2.   defmacro my_macro(a, b, c) do
  3.     quote do
  4.       do_this(unquote(a))
  5.       ...
  6.       do_that(unquote(b))
  7.       ...
  8.       and_that(unquote(c))
  9.     end
  10.   end
  11. end

不如这样:

  1. defmodule MyModule do
  2.   defmacro my_macro(a, b, c) do
  3.     quote do
  4.       # Keep what you need to do here to a minimum
  5.       # and move everything else to a function
  6.       do_this_that_and_that(unquote(a), unquote(b), unquote(c))
  7.     end
  8.   end
  10.   def do_this_that_and_that(a, b, c) do
  11.     do_this(a)
  12.     ...
  13.     do_that(b)
  14.     ...
  15.     and_that(c)
  16.   end
  17. end

这使得你的代码更清晰,也更容易测试和维护,因为你可以直接调用和测试do_this_that_and_that/3.这也有助于你为那些不愿意依赖宏的开发者来设计一个实际的API.

现在,我们结束了对宏的介绍.下一章我们将简短得讨论DSL,展示如何混合宏和模块属性,来注释和扩展模块与函数.