Map over a map and create a new map?

[mrkurt]

Hello! I’m trying to get more comfy with idiomatic elixir, and it seems like one line anonymous fn {} -> ... end calls might not be ideal. Maybe they are, but I’m curious if there’s a cleaner way to do a map over a map and get another map.

Here’s what I have:

Enum.map(m, fn {k,v}-> {k, length(v)} end) |> Map.new

Is there a way to write this more concisely? At first I thought capture syntax might be the way, but I can’t find a function to capture that creates a tuple.

---

And for bonus points, can you destructure capture arguments? Because I also have one of these guys:

|> Enum.flat_map(fn {_, %{metas: metas}} -> metas end)

—edit—
For the second example, I came up with this (which does indeed make me happier):

|> Map.values
|> Enum.flat_map(&Map.get(&1, :metas))

[derek-zhou]

@mrkurt

Here’s what I have:

Enum.map(m, fn {k,v}-> {k, length(v)} end) |> Map.new

:maps.map(fn _k, v -> length(v) end, m)

maybe not idiomatic, but erlang library comes in handy here.

[srowley]

I might use for:

for {k, v} <- m, do: {k, length(v)}, into: %{}

[kokolegorille]

What about skipping the first Enum.map?

Map.new(m, & {elem(&1, 0), String.length(elem(&1, 1))})

@srowley

I might use for:

for {k, v} <- m, do: {k, length(v)}, into: %{}

You can also use for with reduce.

for {k, v} <- m, reduce: %{} do acc -> Map.put(acc, k, String.length(v)) end

or Enum.reduce directly

Enum.reduce(m, %{}, fn {k, v}, acc -> ... end)

[50kudos]

@mrkurt

Enum.map(m, fn {k,v}-> {k, length(v)} end) |> Map.new

Sure!

Enum.into(m, %{}, fn {k,v} -> {k,length(v)} end)
Enum.into(%{a: [1], b: [1,2]}, %{}, fn {k,l} -> {k,length(l)} end)

[sabiwara]

@mrkurt

Enum.map(m, fn {k,v}-> {k, length(v)} end) |> Map.new

Actually Map.new/2 accepts a function, so you can also directly call Map.new(m, fn {k,v}-> {k, length(v)} end).

[50kudos]

It took 5 replies to get the most straight solution for such a simple question. I believe normally people would write what mrkurt already wrote which is not “not concise” at all.

[kokolegorille]

You might not have seen I used Map.new/2 in my reply

[sabiwara]

Oh sorry I missed it!

Also worth noting, Map.new/2 should be the fastest option as well according to this benchmark.

[mrkurt]

@sabiwara

Actually Map.new/2 accepts a function, so you can also directly call Map.new(m, fn {k,v}-> {k, length(v)} end).

and

@kokolegorille

What about skipping the first Enum.map?

Map.new(m, & {elem(&1, 0), String.length(elem(&1, 1))})

Oh my gosh these are great. That Map.new/2 function was exactly what I was looking for. My brain seems to handle the inline function better than complex capture.

[eksperimental]

Here’ s reply number 6.

Enum.into(m, %{}, fn {k,v}-> {k, length(v)} end)

[idlehands]

This would have been my solution, though I would have put the into: before the do: