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

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?

put_in and get_and_update_in have the same limitation I described, and I don’t know of any Access functions that do what I’m looking for (do correct me if they exist).

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.

Yeah, that would explain why Access behaviour doesn’t cover this. I obviously only use this for plain maps-of-maps. Still, it could be part of the Map module?

Nobody is stopping you from creating helpers that you use because that is a simplifying assumption that you want to make in your own code and your own structures.

But in general terms looking at just [:a, :b, :c] the types of the values referenced by :a and b: can’t be known unless they already exist - with :c the type is known because you are giving it the value. Map simply manages the keys and the values - it doesn’t want to make any assumptions about the type of values it manages so that it can be generic.

Fair point, thanks @peerreynders

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.

Ahhh, very cool. I’d seen Access.key before but never made the connection that I could use it like that. Thanks Michał!

This is really great, does anyone one know why it’s in Kernel and not Map, though?

put_in can manipulate anything that Access supports, not just maps. For instance:

iex(1)> a = {1, 2, :x}
{1, 2, :x}
iex(2)> put_in a, [Access.elem(2)], :foo
{1, 2, :foo}