Anonymous function style

I had the same reaction and preference when I first started learning Elixir. There may be some real difference between them that I am not aware of; I just think of it as a style difference.

Over time as I got accustomed to referring to a function as Module.function/arity, the former syntax (i.e. &String.length/1) became more natural and the latter started to feel redundant/unnecessary.

2 calls vs 1

Hmmm… can you explain a bit more? I’m learning yet.

I did not get how the &String.length(&1) is called twice, why is this so?

It’s not that that function is called twice, but it causes two function calls.

Using &f(&1) needs to first call the anonymous function which calls then the inner function call. Using &f/1 creates a more direct “reference” to the target function and therefore removes one level of indirection.

But something like this will be optimised by the compiler.
For example:

  def foo(map) do
    map
    |> Enum.map(&String.upcase/1)
    |> Enum.map(&String.upcase(&1))
  end

becomes

foo(_map@1) ->
    'Elixir.Enum':map(
      'Elixir.Enum':map(_map@1, fun 'Elixir.String':upcase/1),
      fun 'Elixir.String':upcase/1).

But &String.upcase/1 should be the preferred form.

Besides the points above, if you’re not reordering or transforming arguments before calling the existing function, the Mod.fun/arity style is more succinct to read and write, especially for functions with arity > 1. fun(&1, &2, &3) is repetitive in a way that isn’t productive.