skosch

Put/update deep inside nested maps (and auto-create intermediate keys)

To my knowledge, put_in, Map.update etc. all have the one limitation of not automatically creating intermediate keys when needed (for example, put_in(%{a: %{}}, [:a, :b, :c], 42) will fail). But – despite all the risks – this would be useful to have: for instance, I often use reduce to create a nested, aggregate representation of a list of complex objects (say, counting occurrences by categories and sub-categories), which is a one-liner when you don’t have to worry about intermediate keys (think mkdir -p).

The implementation is simple enough (see deep_update example below, which I’m already using all over my projects). I have a nagging feeling this must already be part of Elixir’s standard library and I just don’t know about it? If not, is there a particular reason it isn’t?

  %spec deep_update(map(), [any()], any(), any() -> any()) :: map()
  def deep_update(map, [leaf_key], default, update_func) do
    updated_leaf = if is_map(map) and Map.has_key?(map, leaf_key) do
      update_func.(map[leaf_key])
    else
      default
    end
    Map.put(map, leaf_key, updated_leaf)
  end
  def deep_update(map, [key | key_tail], default, update_func) do
    if is_map(map) and Map.has_key?(map, key) do
      new_branch = deep_update(map[key], key_tail, default, update_func)
      Map.put(map, key, new_branch)
    else
      new_branch = deep_update(%{}, key_tail, default, update_func)
      Map.put(map, key, new_branch)
    end
  end

11 comments

#data-structures #maps #immutability

5 20651 11

2022-02-07 21:38:33 UTC

Marked As Solved

michalmuskala

You can achieve this today using Access.key/2:

put_in(%{a: %{}}, Enum.map([:a, :b, :c], &Access.key(&1, %{})), 42)

If you use it often, you could wrap it in a function to do this automatically for you.

Post #7

Also Liked

jonericcook

@skosch from reading the solutions here i did this (thougt id share for the next person)

  def map_put(data, keys, value) do
    # data = %{} or non empty map
    # keys = [:a, :b, :c]
    # value = 3
    put_in(data, Enum.map(keys, &Access.key(&1, %{})), value)
  end

  def many_map_puts(data, keys_values) do
    # data = %{} or non empty map
    # keys_values = [[keys: [:a, :b, :c], value: 4],[keys: [:z, :y, :x], value: 90]]
    Enum.reduce(keys_values, data, fn x, data ->
      map_put(data, x[:keys], x[:value])
    end)
  end

iex(1)> m = [[keys: [:a, :b, :c], value: 4],[keys: [:z, :y, :x], value: 90]]
[[keys: [:a, :b, :c], value: 4], [keys: [:z, :y, :x], value: 90]]
iex(2)> many_map_puts(%{}, m)
%{a: %{b: %{c: 4}}, z: %{y: %{x: 90}}}

Post #11

peerreynders

Not entirely sure if this addresses what you are trying to accomplish but have you had a look at Kernel.put_in/3, Kernel.get_and_update_in/3 and the like - and Access behavior?

Post #1

peerreynders

So if I understand you correctly you want

put_in(%{a: %{}}, [:a, :b, :c], 42)

to result in

%{a: %{b: %{c: 42)} } }

One problem I see is that you are assuming that :b should refer to a Map value i.e. that the nested structure is a homogenous Map. The Access data[key] syntax is right out of the box also supported by Keyword lists - and any other structure that cares to implement the Access behaviour so there is some ambiguity right there - just because there is a key doesn’t automatically mean it should be a Map.

Post #3