有一篇关于这种行为的优秀博客文章: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。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的遗产，即能够调用没有括号的函数。

显然涉及到Arity，但让我们先把它放在一边，使用没有参数的函数。在像javascript这样必须使用括号的语言中，很容易区分将函数作为参数传递和调用函数。只有在使用括号时才调用它。

my_function // argument
(function() {}) // argument

my_function() // function is called
(function() {})() // function is called

As you can see, naming it or not does not make a big difference. But elixir and ruby allow you to call functions without the brackets. This is a design choice which I personally like but it has this side effect you cannot use just the name without the brackets because it could mean you want to call the function. This is what the & is for. If you leave arity appart for a second, prepending your function name with & means that you explicitly want to use this function as an argument, not what this function returns.

现在匿名函数有点不同，因为它主要用作参数。这也是一种设计选择，但其背后的原因是，它主要用于以函数为参数的迭代器类型的函数。所以显然你不需要使用&，因为默认情况下它们已经被认为是参数了。这是他们的目的。

最后一个问题是，有时候你必须在代码中调用它们，因为它们并不总是与迭代器类型的函数一起使用，或者你可能自己编写了迭代器。对于这个小故事，由于ruby是面向对象的，主要的方法是在对象上使用call方法。这样，就可以保持非强制括号行为的一致性。

my_lambda.call
my_lambda.call()
my_lambda_with_arguments.call :h2g2, 42
my_lambda_with_arguments.call(:h2g2, 42)

现在有人想出了一个捷径，基本上看起来像一个没有名字的方法。

my_lambda.()
my_lambda_with_arguments.(:h2g2, 42)

这也是一种设计选择。现在elixir不是面向对象的，因此我们肯定不会使用第一种形式。我不能说José，但它看起来像是elixir中使用的第二种形式，因为它看起来仍然像一个带有额外字符的函数调用。它已经足够接近函数调用了。

我没有考虑所有的利弊，但看起来在这两种语言中，只要对匿名函数强制使用方括号，就可以只使用方括号。看起来是这样的:

强制括号VS符号略有不同

在这两种情况下，你都是例外，因为你让两者表现不同。既然有区别，您不妨让它变得明显，并使用不同的符号。强制性的括号在大多数情况下看起来很自然，但当事情没有按计划进行时，就会很混乱。

给你。这可能不是最好的解释因为我简化了大部分细节。此外，大部分都是设计选择，我试图给出一个理由，而不是评判它们。我喜欢elixir，我喜欢ruby，我喜欢没有括号的函数调用，但像你一样，我发现结果有时相当误导。

在长生不老药中，它只是一个额外的点，而在红宝石中，你在这个上面有块。block很神奇，我很惊讶你可以用block做多少事情，但它们只在你只需要一个匿名函数的时候起作用，也就是最后一个参数。然后，由于您应该能够处理其他场景，这里就出现了整个方法/lambda/proc/块的混乱。

无论如何……这超出了范围。

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

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

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

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

有一篇关于这种行为的优秀博客文章: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 ->语法用于使用匿名函数。使用var.()只是告诉elixir，我想让你使用带有func的var并运行它，而不是将var引用为仅保存该函数的东西。

Elixir有一个常见的模式，在这个模式中，我们没有在函数内部使用逻辑来查看应该如何执行，而是根据我们拥有的输入类型来匹配不同的函数。我认为这就是为什么我们在function_name/1的意义上使用arity来引用事物的原因。

习惯使用简写函数定义(func(&1)等)有点奇怪，但当您尝试管道或保持代码简洁时很方便。