defmodule AA do
defmodule BB do
defmodule CC do
...
end
end
end
now is there a way get all the parents reversely?
For example:
[AA.BB.CC, AA.BB, AA]
It should noted, maybe the user named a module like Testy.AA, I just need to explore nested module, I mean module inside the other module. and I have always the last one module name, AA.BB.CC
iex(3)> defmodule AA do
...(3)> defmodule BB do
...(3)> defmodule CC do
...(3)> def where_am_i do
...(3)> IO.puts(__MODULE__)
...(3)> end
...(3)> end
...(3)> end
...(3)> end
iex(4)> AA.BB.CC.where_am_i
Elixir.AA.BB.CC
:ok
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.
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
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>.