elixir - 为什么我们需要 Elixir 中的函数 "capture operator"？

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    

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

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

基本上我不理解 & capture 运算符的用例以及它提供的优势。

Answer 1

在上面的示例中，您已将匿名函数 fn x -> x + x end 绑定(bind)到变量 double。当您传递命名函数时，将使用捕获运算符。如果要保存/传递命名函数，您需要一种方法来指示它是命名函数，而不是变量。您可以在此处使用捕获 &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 是变量绑定(bind)，double.(1) 是对绑定(bind)到变量 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 

一个变量一次只能有一个绑定(bind)。因此，它所指的内容并不存在歧义。然而，一个命名函数可以有多个具有不同参数的子句。因此，如果我们只提供函数名称，那么我们所引用的子句就会含糊不清。