How to flatten a map?

Can you speak a bit about your use case? What do you want to do if sub-maps include the same key as a parent map ie: %{foo: %{bar: 1}, bar: 2}

Wow, thanks for super fast reply !
In my scenario it is impossible that that sub maps would include same key/s as parent map.
All keys are always unique.

Are there any datastructures other than maps, like lists?

Hm… I don’t think so.
I see more background information is needed.

Here is explanation that I am doing.

1. I use HTTPoision to fetch Json data
2. I convert response to map using Poision.parse
3. To my understanding I receive list with maps in other words (enumerable)
4. I Enum.each(item, fn map → some modification end)

Here I receive a map, that contains other maps - sub maps.
Before, I can proceed further I need to flatten the map.

Here is a slightly simpler implementation that you may be able to evaluate more easily:

defmodule Foo do

  def flatten_map(map) when is_map(map) do
    map
    |> Map.to_list
    |> do_flatten([])
    |> Map.new
  end

  defp do_flatten([], acc), do: acc

  defp do_flatten([{_k, v} | rest], acc) when is_map(v) do
    v = Map.to_list(v)
    flattened_subtree = do_flatten(v, acc)
    do_flatten(flattened_subtree ++ rest, acc)
  end

  defp do_flatten([kv | rest], acc) do
    do_flatten(rest, [kv | acc])
  end
end

Thank your for the example, I really appreciate!
Yes, your example has more clear process flow.
But, one step is still not very obvious to me.

First of all, I checked what data type I receive from Poison, and it is a list.
So, some changes needs to be applied:

def flatten_map(list) when is_list(list) do
list
|> do_flatten()
|> Map.new
end

So, the process flow is the following:

1. I call flatten_map(list) and submit list as an argument.
2. Function “flatten_map” checks if argument is a list , and if yes, it proceeds.
3. The function “do_flatten()” is called with a list and accumulator [ ] arguments are passed.
4. If list is empty, then due to pattern matching the following function is called and empty list is returned:

defp do_flatten(, acc), do: acc

please correct me if I am wrong.

5. Else if list is not empty the following function will be pattern matched:

defp do_flatten([{_k, v} | rest], acc) when is_map(v) do
v = Map.to_list(v)
flattened_subtree = do_flatten(v, acc)
do_flatten(flattened_subtree ++ rest, acc)
end

This function receives 2 arguments, list and accumulator.
List is split into: Head | Tail , this way we take first item of the list.
At the same time we pattern Head with {_k, v} and then check if v is a map.

It is not clear how the pattern matching works here ?
At this point map %{key, value} is pattern matched to tuple {_k, v } ?
Or is it a typo and should be a %{ _k, v }

Then we know that “v” is a map, so we convert it to list.
Then ** do_flatten** for subbtree → this goes recursevly until reaches the point that it maches: [], acc and then acc is returned.
Then:

do_flatten(flattened_subtree ++ rest, acc)

Here we take list of subtree and join with Tail (rest) and repeat the process passing, list with accumulator. So far seems clear to me…

The only question left, when last function is called ?
In which scenario the pattern match will be matched ?

defp do_flatten([kv | rest], acc) do
do_flatten(rest, [kv | acc])
end

While I was re-reading my reply understood, that if v is not a map, then the last function is executed.

Then we call do_flatten and pass Tail (rest) as a first argument, and a list by using kv as Head and acc as Tail ?

I would highly appreciate if you could correct me if my understanding is wrong.

I spend few more minutes, and finally understood, that we converted the map to list, and therefore we don’t need to pattern match to map %{k, v}.

Furthermore, no changes were needed.
As according to steps I described, I enumerate the list and take the Map as each item, therefore your code is exactly that I need.

Thank you very much , one more time!

You don’t pattern match maps with %{ _k, v }, you do it with %{^k => v}.

Note the pin.

In this scenario, I realised that I don’t need to pattern match to map.
But in other case scenario, I would definitely forgot about the pin.
Definitely need to make a note about the pin :slight_smile
Thank you for the advise!