Hi,
I am relatively new to Elixir and need a support from more advanced users.
I try to do a simple thing → Flatten Map
But Elixir and functional programming in general is a bit new to me.
I found online a solution, but it looks overcomplicated.
I wonder if maybe there is a solution out of the box provided by the language.
I tried to find something like Map.flatten(%{a: 1, %{b: 2}}) but with no success.
It would be great if you could advice that is the best practice ?
Meanwhile, I found the solution online, please see the code below.
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.
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:
I call flatten_map(list) and submit list as an argument.
Function “flatten_map” checks if argument is a list , and if yes, it proceeds.
The function “do_flatten()” is called with a list and accumulator [ ] arguments are passed.
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.
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.
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!