为什么我们在 Elixir 中需要一个函数“捕获运算符”？

Question

有人能解释一下为什么在 Elixir 中需要用与号前缀表示的“捕获运算符”吗？在其他语言中，它不是：

Python 3.6.0 |Anaconda 4.3.0 (64-bit)| (default, Dec 23 2016, 12:22:00) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-1)] on linux

>>> def double(x):
...   return(x + x)
... 
>>> double(2)
4
>>> dbl = double
>>> dbl(2)
4

显然，这在 Elixir 中也是一样的：

iex(2)> double = fn x -> x + x end
#Function<6.118419387/1 in :erl_eval.expr/5>
iex(3)> double.(2)
4                                                                                                                                 
iex(4)> dbl = double                                                                                                              
#Function<6.118419387/1 in :erl_eval.expr/5>                                                                                      
iex(5)> dbl.(2)                                                                                                                   
4    

那么为什么，例如在这里，如果函数已经可以在没有所述运算符的情况下传递，我们还需要使用捕获运算符吗？函数的普通旧名称不是已经“捕获”了它吗？

iex(10)> Enum.map([1, 2, 3], double)
[2, 4, 6]

基本上我不了解 & 捕获运算符的用例及其提供的优势。

Answer 1

在上面的示例中，您已将匿名函数绑定fn x -> x + x end到变量double。传递命名函数时使用捕获运算符。T 保存/传递一个命名函数，你需要一种方法来表明它是一个命名函数，而不是一个变量。这是您使用捕获&name/arity语法的地方。

defmodule FunWithFuns do
  def get_env, do: Application.get_all_env(:my_app)
  def get_env(item), do: Application.get_env(:my_app, item)

  def some_function do
    IO.inspect get_env
    Enum.map([:item1, :item2], get_env)
  end
end

get_env在这种情况下，您如何解决？它是对 的调用get_env/0还是对 的引用get_env/1？在匿名函数的情况下，double是变量绑定，double.(1)是绑定到变量的函数的调用double。

请注意，在没有 的情况下调用零元函数()已被弃用，但仍然有效。我想一旦删除它，编译器可能会做出选择，但即使如此，也可能有其他原因导致它不起作用。

另一个原因：让我们假设，例如，我们确实支持使用命名函数名称。我们如何支持这一点：

# contrived example
defmodule MoreFunWithFuns do
  def fun1, do: :something_stateful
  def fun1(x), do: x + 1
 
  def higher(list, fun) do
    cond do
      is_function(fun, 0) -> fun.() |> process_state
      is_function(fun, 1) -> Enum.map(list, fun) |> process_state
    end
  end

  def run(list) do
    higher(list, fun1) # which fun1 here?
  end
end 

一个变量一次只能有一个绑定。因此，它所引用的内容没有歧义。但是，命名函数可以有多个具有不同元数的子句。因此，如果我们只提供函数名称，那么我们所指的是哪个子句就会有歧义。