Is there possible to find parent module in nested module?

Module.split and Module.concat may be what you’re after.

Module.split(Very.Long.Module.Name.And.Even.Longer)
["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
Module.split("Elixir.String.Chars")
["String", "Chars"]

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

__MODULE__/0 docs | Kernel.SpecialForms — Elixir v1.13.4

unfortunately, in this way we just separate the module name, not getting the parent, for example if we have a module like:

defmodule Testy.AA do
  defmodule BB do
    defmodule CC do
      ...
    end
  end
end

it returns ["Testy", "AA", "BB", "CC"], and the Testy module maybe exist and we do not need it just nested module inside the module should be counted

As I said, I have already the last module name.

But your answer gives me an idea that should be tested

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.

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

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