Manipulate Nested Map

Do you know about Kernel.put_in/2 and Kernel.put_in/3? It might be just what you are looking for.

user_id = "1"

# extract `user_sports` from data
%{"user_sports" => user_sports} = data = %{
  "zip" => "",
  "location" => "",
  "user_sports" =>  %{
    "0" => %{"sport_id" => "1", "user_id" => ""},
    "1" => %{"sport_id" => "1", "user_id" => ""}
  }
}

# put user_id into user_sports
user_sports =
  user_sports
  |> Enum.map(fn {key, user_sport_info} -> 
    {key, Map.put(user_sport_info, "user_id", user_id)}
  end)
  |> Enum.into(%{})

# update data with new user_sports
data = %{data | "user_sports" => user_sports}

I hoped

put_in(data, ["user_sports", Access.all(), "user_id"], user_id)

would also work, but it didn’t. Access.all() only works with lists:

iex(4)> put_in(data, ["user_sports", Access.all(), "user_id"], user_id)
** (RuntimeError) Access.all/0 expected a list, got: %{"0" => %{"sport_id" => "1", "user_id" => ""}, "1" => %{"sport_id" => "1", "user_id" => ""}}
    (elixir) lib/access.ex:626: Access.all/3
    (elixir) lib/map.ex:773: Map.get_and_update/3
    (elixir) lib/kernel.ex:2057: Kernel.put_in/3

One way to do it (not tested):

new_user_sports =
  initial_data
  |> get_in(["user_sports"])
  |> Enum.map(fn {k, v} -> 
    {k, Map.put(v, "user_id", user.id)}
  end)

Map.put(initial_data, "user_sports", new_user_sports)

Enum.map would return a list of key-value tuples, not a map, so something like Enum.into(%{}) is required for the initial structure to stay intact.

Or a reduce function

Enum.reduce(user_sports, %{}, fn {key, user_sport_info}, acc ->
  Map.put(acc, key, Map.put(user_sport_info, "user_id", user_id))
end)

or a for comprehension

for {key, user_sport_info} <- user_sports, into: %{} do
  {key, Map.put(user_sport_info, "user_id", user_id)}
end

But both of these would be less efficient than a map.

Enum.into(%{}) is better imho

update_in(
  map["user_sports"],
  &:maps.map(fn _key, user_sport -> %{user_sport | "user_id" => user_id} end, &1)
)

Also, Map.new(enum, fun) can be used instead of enum |> Enum.map(fun) |> Enum.into(%{}).

If you don’t mind writing a helper function, the logic becomes simpler when you break it into pieces. For instance,

def update_sports_map(map) do
  Map.new(map, fn({index, attrs}) -> {index, Map.put(attrs, "user_id", "id")} end)
end

new_data = Map.update!(data, "user_sports", &update_sports_map/1)

Awesome solutions. Thanks a lot I feel like I was slowed on the uptake

@idi527: I tried it with Access.fetch too, but unluckily it does not seem to be as flexible as I need to have it

The only thing I still don’t understand is the fact that the following does not work:

Enum.each(user_sports, fn {k, v} ->
  Map.replace!(user_sports, k, %{v | "user_id" => user.id})
end)

Can anyone explain this?

That’s because most data types in elixir/erlang are immutable. So Enum.each won’t mutate user_sports.

To expand on what @idi527 said, since data is immutable the way an update works is to have a function return an updated version. So something like

data = update_fun(data)

works by returning the updated data and switching the label data to the new data. The original data is not modified and is still there, until the VM sees that it’s no longer referenced and garbage collects it.

Enum.each(enumerable, fun) simply calls fun for every element of the enumerable, and then returns :ok. This means any value returned by fun doesn’t get used and winds up being garbage collected. The main use for Enum.each is to call a function with a side-effect, like printing to an IO device or sending a message to another process, for each element.