在elixir中，我们使用def来简单地定义函数，就像我们在其他语言中所做的那样。 Fn创建一个匿名函数，请参考此说明

Elixir为函数提供了可选的花括号，包括圆整度为0的函数。让我们看一个例子，为什么单独的调用语法很重要:

defmodule Insanity do
  def dive(), do: fn() -> 1 end
end

Insanity.dive
# #Function<0.16121902/0 in Insanity.dive/0>

Insanity.dive() 
# #Function<0.16121902/0 in Insanity.dive/0>

Insanity.dive.()
# 1

Insanity.dive().()
# 1

如果不区分这两种类型的功能，我们就不能说什么是Insanity。Dive意味着:获取一个函数本身，调用它，或者也调用结果匿名函数。

有一篇关于这种行为的优秀博客文章:link

两种类型的函数

If a module contains this: fac(0) when N > 0 -> 1; fac(N) -> N* fac(N-1). You can’t just cut and paste this into the shell and get the same result. It’s because there is a bug in Erlang. Modules in Erlang are sequences of FORMS. The Erlang shell evaluates a sequence of EXPRESSIONS. In Erlang FORMS are not EXPRESSIONS. double(X) -> 2*X. in an Erlang module is a FORM Double = fun(X) -> 2*X end. in the shell is an EXPRESSION The two are not the same. This bit of silliness has been Erlang forever but we didn’t notice it and we learned to live with it.

在调用fn时

Iex > f = fn(x) -> 2 * x结束 #函数< erl_eval.6.17052888 > iex > f。(10) 20. 在学校里，我学会了用f(10)而不是f.(10) -来调用函数 这是一个“真正的”函数，它的名字是Shell.f(10) shell部分是隐式的，所以它应该 记作f(10) 如果你就这样待着，接下来的二十年 用你的生命解释为什么。

只有第二种函数似乎是一类对象，可以作为参数传递给其他函数。模块中定义的函数需要封装在fn中。有一些语法糖，看起来像otherfunction(myfunction(&1， &2))，为了使这更容易，但为什么它是必须的?为什么我们不能只使用其他函数(myfunction) ?

您可以执行其他函数(&myfunction/2)

由于elixir可以执行不带括号的函数(如myfunction)，使用otherfunction(myfunction))，它将尝试执行myfunction/0。

因此，您需要使用捕获操作符并指定函数，包括arity，因为您可以使用相同名称的不同函数。因此,myfunction / 2。

为了明确命名，它们都是函数。一个是命名函数，另一个是匿名函数。但你是对的，它们的工作方式有些不同，我会解释为什么它们是这样工作的。

我们从第二个开始，fn。fn是一个闭包，类似于Ruby中的lambda。我们可以这样创建它:

x = 1
fun = fn y -> x + y end
fun.(2) #=> 3

一个函数也可以有多个子句:

x = 1
fun = fn
  y when y < 0 -> x - y
  y -> x + y
end
fun.(2) #=> 3
fun.(-2) #=> 3

现在，让我们尝试一些不同的东西。让我们尝试定义不同的子句，期望不同数量的参数:

fn
  x, y -> x + y
  x -> x
end
** (SyntaxError) cannot mix clauses with different arities in function definition

哦，不!我们得到一个错误!我们不能混合使用期望不同数量参数的子句。一个函数总是有固定的元数。

现在，让我们讨论命名函数:

def hello(x, y) do
  x + y
end

正如预期的那样，它们有一个名称，还可以接收一些参数。然而，它们不是闭包:

x = 1
def hello(y) do
  x + y
end

这段代码将无法编译，因为每次看到def时，都会得到一个空变量作用域。这是他们之间的一个重要区别。我特别喜欢这样一个事实:每个命名函数都是从头开始的，你不会把不同作用域的变量混在一起。你有明确的界限。

我们可以将上面命名的hello函数作为匿名函数检索。你自己也提到过:

other_function(&hello(&1))

And then you asked, why I cannot simply pass it as hello as in other languages? That's because functions in Elixir are identified by name and arity. So a function that expects two arguments is a different function than one that expects three, even if they had the same name. So if we simply passed hello, we would have no idea which hello you actually meant. The one with two, three or four arguments? This is exactly the same reason why we can't create an anonymous function with clauses with different arities.

从Elixir v0.10.1开始，我们就有了捕获命名函数的语法:

&hello/1

这将捕获带有arity 1的本地命名函数hello。在该语言及其文档中，使用hello/1语法标识函数是非常常见的。

这也是Elixir使用点来调用匿名函数的原因。由于不能简单地将hello作为函数传递，而是需要显式地捕获它，因此命名函数和匿名函数之间有一个自然的区别，并且调用它们的不同语法使一切更加显式(由于Lisp 1和Lisp 2的讨论，Lispers应该熟悉这一点)。

总的来说，这就是为什么我们有两个函数，为什么它们表现不同的原因。

我一直不明白为什么对此的解释如此复杂。

这实际上只是结合了ruby风格的“不带paren的函数执行”的实际情况的一个非常小的区别。

比较:

def fun1(x, y) do
  x + y
end

To:

fun2 = fn
  x, y -> x + y
end

虽然这两个都只是标识符……

Fun1是一个描述用def定义的命名函数的标识符。 Fun2是描述变量(恰好包含对函数的引用)的标识符。

当你在其他表达式中看到fun1或fun2时，这意味着什么?在计算该表达式时，是调用引用的函数还是只是引用内存外的值?

在编译时没有很好的方法知道。Ruby可以自省变量名称空间，以查明变量绑定是否在某个时间点遮蔽了函数。Elixir正在编译，不能真正做到这一点。这就是点符号的作用，它告诉Elixir它应该包含一个函数引用，并且应该调用它。

这真的很难。假设没有点符号。考虑下面的代码:

val = 5

if :rand.uniform < 0.5 do
  val = fn -> 5 end
end

IO.puts val     # Does this work?
IO.puts val.()  # Or maybe this?

根据上面的代码，我认为很清楚为什么你必须给Elixir提示。想象一下，如果每个变量去引用都必须检查一个函数?或者，想象一下，总是推断变量解引用使用的是函数需要什么样的英雄主义?