Style: cleanest way to pipe to an Enum.map with an anonymous function

Why does it feel wrong?

I do it exactly that way, except that I lineup end) and |> in the same column:

list
|> Enum.map(fn a ->
  a
end)
|> …

But to be honest, I prefer to simply give that function a name and def(p) it:

list
|> Enum.map(&id/1)
|> …

Or using const (as an example with extra arguments:

list
|> Enum.map(&const(&1, 5))

def const(_, b), do: b
def id(a), do: a

I find that inline anonymous function definitions are a bit of a bad habit in the JavaScript world.

Using lambda-style is fine when the function is mercilessly short. Otherwise just define a module function and use the capture syntax. And if you need to use a closure define a module function that returns an anonymous function with a closure.

defp is_user(username),
  do: fn [un | _] -> un == username end

defp extract_pwd([_ | [pwd | _]]),
  do: pwd

...

[value] =
  logins
  |> (Enum.filter_map (is_user username), &extract_pwd/1)
  |> # go on

.

defp is_callable(%{"metadata" => %{"callable" => "Callable"}}), do: true
defp is_callable(_), do: false

defp extract_slug_name(%{"slug" => slug, "title" => name}),
  do: %{slug: slug, name: name}

...

"candidates"
  |> Cosmic.get_type()
  |> Enum.filter(&is_callable/1)
  |> Enum.map(&extract_slug_name/1)
  |> Poison.encode()

Ah yeah, I am a recovering Node.js programmer. Then I learned Lisp and tried to program Javascript for fun for a while with only expressions, which lead to lots of immediately invoked function expressions and .filter .map chains.

I’ll define private functions. Thanks everyone!