Access attribute in list of lists


Been lurking here for a while (that is, via google), gotten a lot of help from people’s Q&As in the past, but I’ve gotten stuck on something that I don’t quite see an answer for in the documentation or the forums here. I feel like it’s something very simple, but I’m just not quite grokking how Access works.

I know how to access stuff in nested maps, but my question is specifically about stuff structured like this:
[ %StructFromAListOfStructs{ a_list_nested_in_that_struct: [ %{ some_attribute: "Blah blah blah" } ] }, ... ]

Each map/struct in this list has an attribute which returns a list of maps, and I want to access the keys in those nested lists.

Now if this was simply a nested map, I’d know what to do, but I get confused at this point. I’m sure if I studied the docs a little harder I could figure it out, but I figured I’d leverage the expertise here and hopefully save myself some time (thanks in advance!).

What I normally do in these sorts of situations is Enum.flat_map the list and then pipe into an to access the attribute. But that’s two loops round what is (in my case) some very long lists. Is there a more efficient way to do this?

(BTW, this is not struct specific, just used that for convenience of self-commenting my example.)

You likely want to use Kernel.get_in with some helpers from the Access module such as and Access.key. Your example is a bit too vague to offer any concrete example, but the hexdocs of those functions should get you going.

You could use get_in or Access as @gregvaughn said, but you’ll definitely come across some problems with structures and list traversal.

The best solution is to use library called Pathex. It works with structures better than Access does, plus it is more efficient.

So, with Pathex, your code for accessing this data would like this

use Pathex
import Pathex.Lenses

# Define the path
def path_to_data() do
  all() ~> path(:a_list_nested_in_that_struct) ~> all() ~> path(:some_attribute)

# Use the path
def get_data(list_of_lists) do
  Pathex.get(list_of_lists, path_to_data())

def set_data(list_of_lists, value) do
  Pathex.set(list_of_lists, path_to_data(), value)

@Rory You can use a nested reduce calls. The actual code would be different in each specific use case. For example if you want to take soonest date from such a nested data then you do not need to collect all elements and simply work on one single data, for example:

defmodule ToDo do
  defmodule List do
    defstruct ~w[items name]a

    defmodule Item do
      defstruct ~w[content date]a

defmodule Example do
  def get_data do
        items: [
          %ToDo.List.Item{content: "Do X", date: ~D[2022-12-15]},
          %ToDo.List.Item{content: "Do Y", date: ~D[2022-12-16]},
          %ToDo.List.Item{content: "Do Z", date: ~D[2022-12-17]}
        name: "List A"
        items: [
          %ToDo.List.Item{content: "Do X", date: ~D[2022-12-01]},
          %ToDo.List.Item{content: "Do Y", date: ~D[2022-12-02]},
          %ToDo.List.Item{content: "Do Z", date: ~D[2022-12-03]}
        name: "List B"
        items: [
          %ToDo.List.Item{content: "Do X", date: ~D[2023-01-01]},
          %ToDo.List.Item{content: "Do Y", date: ~D[2023-01-02]},
          %ToDo.List.Item{content: "Do Z", date: ~D[2023-01-03]}
        name: "List C"

  def get_first_date(data) when is_list(data) do
    Enum.reduce(data, nil, fn %ToDo.List{items: items}, acc ->
      Enum.reduce(items || [], acc, fn
        %ToDo.List.Item{date: nil}, acc ->

        %ToDo.List.Item{date: date}, nil ->

        %ToDo.List.Item{date: date}, acc ->
          if, acc) == :lt, do: date, else: acc

|> Example.get_first_date()
|> Date.diff(Date.utc_today())
|> then(&IO.puts("You have still #{&1} free days!"))
# You have still 20 free days!

Look how simple it’s to change. If we would like to take the opposite date then we all we need to do is to change 2 letters i.e. :lt to :gt (when comparing date with acc). If you want to return multiple dates in this example then all you need to do is to change a default acc from nil to [] (empty list) and replace two last nested reduce clauses to:

        %ToDo.List.Item{date: date}, acc ->
          [date | acc]

With nested reduce or alternatively simple pattern matching the whole list is iterated only once. See Enum.reduce/3 for more information.

1 Like