I’d do it this way:

defmodule MyModuleHelpers do
  def parent(module) do
    module # e.g. Very.Long.Module
    |> Module.split() # ["Very", "Long", "Module"]
    |> remove_last()
    |> Module.concat() # opposite to split Very.Long
  end

  # Elixir modules are atoms underneath that always start with "Elixir"
  # e.g. :"Elixir.Very" is pritned in console as Very
  # We use the `:Elixir` atom as recursion end
  # and we say that :Elixir does not have parents
  def parents(:Elixir), do: []

  # here is the recursive clause
  # the returned list starts with current module
  # and then calls itself recursively with parent
  # we use the fact that list constructor is itself recursive
  # [Very.Long.Module, Very.Long, Very] == [Very.Long.Module | [Very.Long | [Very | []]]]
  def parents(module) do
    [module | parents(parent(module))]
  end

  # there is no "remove last element" function, so the trick is to reverse and remove first
  defp remove_last(list) do
    list # ["Very", "Long", "Module"]
    |> Enum.reverse() # ["Module", "Long", "Very"]
    |> tl() # tail function gives everything BUT the first element ["Long", "Very"]
    |> Enum.reverse() # ["Very", "Long"]
  end
end

In case it gives you more ideas, there’s a Module.__info__/1 as well.

iex(5)> AA.BB.CC.__info__(:module)
AA.BB.CC

It’s also worth noting that modules aren’t truly nested in Elixir since they’re all flattened into a top level if I recall correctly. The superficial “nesting” via the dot/period is just a namespacing convention.

There’s not a good way, and IMO that’s intentional - the apparent hierarchy of dotted names (Foo.Bar.Baz) doesn’t correspond to any real nesting.

For instance, naming a module Foo.Bar.Baz says precisely nothing about the existence of modules named Foo and Foo.Bar. They could exist, but they aren’t required to like in other languages (for instance, Ruby).

There’s no way to go in the opposite direction either: given a module named Foo.Bar, there’s no API to retrieve every module named Foo.Bar.<whatever>.