Help composing/abstracting list of keys to traverse nested data structures using the Access module

Questions / Help
, ,
1

Hello, I’m looking to dry up some LiveView handle_info/event callbacks that require modifying a nested data structure using update_in/3 in response to CRUD, or rather CUD, actions. The second parameter for update_in/3 is a list of keys that are often functions from the Access module e.g. Access.key!/2 and Access.filter/2.

For the sake of a concrete example, Person has many Pets, Pet has many Toys, and there are callbacks that update a preloaded person struct assigned to the socket after a user adds, updates, and/or deletes a toy. For the add and delete callbacks, update_in/3 only has to reach into the toys list whereas the update callback goes a step further to find the specific toy within in the toy list.

How would I go about abstracting out the common parts of the traverse path?

person =
  %Person{
    pets: [
      %Pet{
        toys: [
          %Toy{}
        ]
      }
    ]
  }

# within toy created callback
update_in(
  person,
  [
    Access.key!(:pets),
    Access.filter(&(&1.id == pet_id)),
    Access.key!(:toys)
  ],
  fn toys -> [toy | toys] end
) 

# within toy deleted callback
update_in(
  person,
  [
    Access.key!(:pets),
    Access.filter(&(&1.id == pet_id)),
    Access.key!(:toys)
  ],
  fn toys -> Enum.reject(toys, &(&1.id == toy_id)) end
) 

# within toy updated callback
update_in(
  person,
  [
    Access.key!(:pets),
    Access.filter(&(&1.id == pet_id)),
    Access.key!(:toys),
    Access.filter(&(&1.id == toy_id))
  ],
  fn toy -> %{toy | new_attributes} end
) 

# composing list of keys within toy updated callback
update_in(
  person,
  [
    Access.key!(:pets),
    Access.filter(&(&1.id == pet_id)),
    Access.key!(:toys)
  ] ++ [Access.filter(&(&1.id == toy_id))],
  fn toy -> %{toy | new_attributes} end
)

As demonstrated above, the first three elements in the second parameter list of keys are shared across all three callbacks. Is there a sensible way to refactor and abstract that out? I imagine some form of macros/quote/unquote would be involved… would the added brevity even be worth it given the increased complexity?

2

update_in/3 and friends are plain functions, and their argument is a plain list (of anonymous functions). The macro-sorcery might be necessary to do things with update_in/2, but not here.

You could do this with functions:

defp toys_for(pet_id) do
  [
    Access.key!(:pets),
    Access.filter(&(&1.id == pet_id)),
    Access.key!(:toys)
  ]
end

# in the created/deleted callbacks:
update_in(
  person,
  toys_for(pet_id),
  fn toys -> [toy | toys] end
) 

# in the updated callback:
update_in(
  person,
  toys_for(pet_id) ++ [Access.filter(&(&1.id == toy_id))],
  fn toy -> %{toy | new_attributes} end
)

You could also split this differently - combine Access.key!(:pets) with the Access.filter and name it pet_with_id or similar.

3 Likes
3

Ahh of course, for some reason didn’t occur to just pass in the ids. Anyways, thanks @al2o3cr and thanks Elixir for first class functions!

1 Like
4

Played around with splitting it like @al2o3cr suggested and got something like this:

  defp access_pet_with_id(id) do
    [
      Access.key!(:pets),
      Access.filter(&(&1.id == id)),
    ]
  end

  defp access_toy_with_id(id) do
    [
      Access.key!(:toys),
      Access.filter(&(&1.id == id)),
    ]
  end

And just for fun, took a crack at generating these formulaic helper functions for any given list of preloaded Ecto structs:

  for struct <- [%Pet{}, %Toy{}] do
    schema = struct.__meta__.schema
      |> Atom.to_string
      |> String.split(".")
      |> List.last
      |> String.downcase

    defp unquote(String.to_atom("access_#{schema}_with_id"))(id) do
      [
        Access.key!(unquote(String.to_atom(schema <> "s"))),
        Access.filter(&(&1.id == id))
      ]
    end
  end

It’s overkill for this toy example, but it might be helpful for others in some situations.

5

This is probably in the realm of chrome plating, but you could even generalize to

  defp access_key_with_id(key, id) do
    [
      Access.key!(key),
      Access.filter(&match?(^id, &1.id)),
    ]
  end
1 Like
6

Shiny! That also opens the door for something like this:

defp access_keys_with_ids(list) when is_list(list) do
  Enum.reduce(list, [], fn {key, id}, acc -> 
    acc ++ access_key_with_id(key, id)
  end)
end

access_keys_with_ids([pets: 1, toys: 2])
=> [
       Access.key!(:pets),
       Access.filter(&match?(1, &1.id)),
       Access.key!(:toys),
       Access.filter(&match?(2, &1.id))
   ]