Recursively accumulate nested maps

Questions / Help
, ,
1

Having an issue similar to https://elixirforum.com/t/whats-the-best-way-to-access-and-retrieve-data-from-deeply-nested-maps-and-lists/613/4.

I have a data structure with a nested map I’d like to accumulate into a list. The problem is I don’t know how to recursively get the maps of nested elements.
Here is a contrived version. I’m trying to get a list of all the c and nested c values. Is there a way to do this?

test "Recursive Maps" do
    #I just want all the c's in a list
    rMap = %{:a => 1, :b => 2, :c => %{ :a => 111, :b => 2222, 
        :c => %{ :a => 212, :b => 323, 
            :c => %{:a => 45, :b => 524, 
                :c => %{}}}}}

    rMap2 = %{:a => 3, :b => 4, 
        :c => %{ :a => 5, :b => 6, 
            :c => %{ :a => 7, :b => 8, 
                :c => %{:a => 9, :b => 10, 
                    :c => %{a: 11, b: 12, c: 13}}}}}
                    
    rMaps = [rMap,rMap2]
    IO.puts "rMaps List of Justcs"
    IO.inspect rMaps
    justCs = justc rMaps
    IO.inspect justCs
    
    justCs = justc3 rMaps
    IO.inspect justCs

end
# Loop through list
def justc3(rMaps) do
    Enum.reduce_while(rMaps, [], fn rMap, acc ->
        if Map.has_key?(rMap,:c) == false do
            {:halt, acc}
        else
            c = Map.get(rMap,:c)
            {:cont, [c] ++ acc} 
        end
    end)
end

def justc(rMaps) do
    justCs = for rMap <- rMaps do
        c = Map.get(rMap,:c)
      #  IO.inspect Enum.count(c)
        if Enum.count(c) == 0 do
            []
        else
            Map.get(rMap,:c) 
        end
    end
end
2

Why not just divide it into two functions that match on having a :c atom (if you want to match on binary keys too, then adding another function that matches on it) and recur, returning the accumulator if no map with :c is passed?

defmodule Test do
  def get_c(acc, %{:c => c}), do: Test.get_c([c | acc], c)
  def get_c(acc, _), do: acc
end

iex(4)> defmodule Test do
...(4)> def get_c(acc, %{:c => c}), do: Test.get_c([c | acc], c)
...(4)> def get_c(acc, _), do: acc
...(4)> end

{:module, Test,
 <<70, 79, 82, 49, 0, 0, 3, 248, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 85,
   0, 0, 0, 9, 11, 69, 108, 105, 120, 105, 114, 46, 84, 101, 115, 116, 8, 95,
   95, 105, 110, 102, 111, 95, 95, 9, 102, ...>>, {:get_c, 2}}

iex(5)> Test.get_c([], %{a: 'test', c: %{a: false, b: true, c: %{c: 1, b: 2, d: 3}}})

[1, %{b: 2, c: 1, d: 3}, %{a: false, b: true, c: %{b: 2, c: 1, d: 3}}]

In case you want to customise at runtime the key that you dig for you could use a case,

def get_arbitrary(acc, %{} = map, key) do
  case map[key] do
    nil -> acc
    value -> get_arbitrary([value | acc], value, key)
  end
end
def get_arbitrary(acc, _, _), do: acc
3

What result do you want to get?

Running justc on rMaps returns

[
  %{a: 111, b: 2222, c: %{a: 212, b: 323, c: %{a: 45, b: 524, c: %{}}}},
  %{a: 5, b: 6, c: %{a: 7, b: 8, c: %{a: 9, b: 10, c: %{a: 11, b: 12, c: 13}}}}
]

for me.

And justc3 on rMaps returns

[
  %{a: 5, b: 6, c: %{a: 7, b: 8, c: %{a: 9, b: 10, c: %{a: 11, b: 12, c: 13}}}},
  %{a: 111, b: 2222, c: %{a: 212, b: 323, c: %{a: 45, b: 524, c: %{}}}}
]

Is that what you want?

Or do you want to get

[nil, 13]

from rMaps?

Can :c be nested inside maps for keys other than :c, like in

%{a: %{c: :c}, c: %{...: ...}}

?

4

Thank you @amnu3387, Not familiar with [c| acc] syntax. How is it that the acc variable gets accumulated to?
@idi527 I wanted to get every instance of :c in any of the maps and add them to a list

5

Can you provide an example? The exact result you want from rMaps in your post.

6

The following is for each map but I’m figuring for rMaps I can write a comprehension to append to a parent list

[
  %{},
  %{a: 45, b: 524, c: %{}},
  %{a: 212, b: 323, c: %{a: 45, b: 524, c: %{}}},
  %{a: 111, b: 2222, c: %{a: 212, b: 323, c: %{a: 45, b: 524, c: %{}}}}
]
7

I just had a little brainfart before, of course that won’t get you 'c’s inside other maps…

defmodule Test do
  def get_cees(map, acc, key) do
    Enum.reduce(map, acc, fn 
      ({k, %{} = v}, acc) when k == key -> Test.get_cees(v, [ v | acc], key)
      ({k, v}, acc) when k == key -> [v | acc]
      ({k, %{} = v}, acc) -> Test.get_cees(v, acc, key)
      (_ , acc) -> acc
      end)
   end
 end

This will though, you match on the arguments that get passed to the reduce function. When you reduce a map you get a {k,v} tuple, so when you get a tuple where v is a map, and the key matches the key you’re searching for, you recur the function, passing v (which is a map), and appending it to the accumulator. When you get a tuple where the value isn’t a map, but the key of the reduction is the key you’re looking for, you just append the value to the accumulator. When you get a tuple where v is a map, but the key isn’t the one you want, you just recur to dig another level, but without appending to the accumulator. Otherwise you just return the accumulator as is, because it means the v isn’t a map (so no need to recur) and the key isn’t the key you want, so no need to append.

Basically [ h | t ] means, give me a list where you append h to another list t (even if empty) and can be used as well to get the head of a list (1 elem), and the tail (n elems) of it.