Access attribute in list of lists

You likely want to use Kernel.get_in with some helpers from the Access module such as Access.at 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)
end

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

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

@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
    end
  end
end

defmodule Example do
  def get_data do
    [
      %ToDo.List{
        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"
      },
      %ToDo.List{
        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"
      },
      %ToDo.List{
        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"
      }
    ]
  end

  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 ->
          acc

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

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

Example.get_data()
|> 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.