Why does Erlang allow putting parentheses after a fun?

Question

This question is about some syntax a partner came across today and though we understand how it works, we don't understand why is it allowed (what is its use?).

Look at this snippet:

fun() -> ok end().

Without the last pair of parentheses this will produce something like:

#Fun<erl_eval.20.82930912>

But with them, the function is evaluated producing:

ok

My question is, why is that syntax allowed in Erlang ? why would I want to create a function just to call it immediately instead of just writing out its contents? is there any practical use to it ?

The only thing we could think about was introducing local variables inside the fun's body (but that would look ugly and unclear to me).

Please note that this other syntax is not allowed in Erlang, even though it follows the same concept of the former:

fun() -> fun() -> ok end end()().  

(It would mean: a function A that returns a function B. And I'm evaluating A (thus producing B) and then evaluating B to get 'ok').

Answer 1

The syntax you mentioned is a natural outcome of Erlang's being functional.

In Erlang, functions are values (stored as closures).

The value of fun() -> ok end is a function, which takes nothing and returns ok. When we put parentheses after it, we are calling that function. Another way to demonstrate this is:

 > F = fun() -> ok end.  
 #Fun<erl_eval.20.80484245>
 > F().                  
 ok

The functions in the second example of yours need to be grouped properly in order for the parser to make sense of them.

As for your question -- "why this syntax is allowed", I'd have to say it's a natural outcome of functions being values in Erlang. This ability enables the functional style of programming. Here is an example:

 > lists:map(fun(X) -> X * 2 end, [1,2,3]).
 [2,4,6]

The above code is in essence this:

 > [fun(X) -> X * 2 end(1), fun(X) -> X * 2 end(2), fun(X) -> X * 2 end(3)].
 [2,4,6]

A "natural outcome" is just a natural outcome, it really doesn't have to be of any practical use. So, you will probably never see code like (fun() -> fun() -> ok end end())(). being used:)