Create sub module with atom name

shahryarjb · August 12, 2023, 8:16am

Hello friends,
I want to create a module inside another module with an atom name:

For example:

  defmacro sub_field(name, _type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    quote do
      defmodule unquote(name) do
        unquote(ast)
      end
    end
  end

If I use Module name, it is okey and creates a sub module for me like:

sub_field(Oop, String.t(), enforce: true) do
    field(:title, String.t())
    field(:fam, String.t())
end

But If I replace Oop with :opp it has invalid module name error.

I tried to convert atom to string and use Macro.camelize() and convert it to atom again ( :Oop), but it does not accept.

Then I print :opp, it just returns :opp in my macro but if I put module name Opp it returns something like this:

{:__aliases__,
 [
   counter: {MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct, 3},
   line: 520
 ], [:Opp]}

now how can use atom to do this?

Thank you in advance

Eiji · August 12, 2023, 9:33am

Weird… when I try this code:

defmodule MyLib do
  defmacro sub_field(name, do: block) do
    quote do
      defmodule unquote(name) do
        unquote(block)
      end
    end
  end
end

defmodule Example do
  import MyLib

  sub_field :opp do
    def sample, do: IO.inspect(__MODULE__)
  end
end

:opp.sample()

then everything is working without any problem. module is print properly and there are no warnings or errors …

shahryarjb · August 12, 2023, 1:48pm

Hello @Eiji, you could not be able to create something Opp.sample() ?

Eiji · August 12, 2023, 2:06pm

Ah, I see … You have tried my example to create a top-level module in another module.

First of all you need to understand something … As same as you can check AST with quote do … end as same you can check how modules are “defined” inside using IO.puts(module).

iex> IO.puts(String)
Elixir.String

iex> IO.puts(Example)
Elixir.Example

iex> IO.puts(:opp)
opp

iex> IO.puts(:Opp)
Opp

With this you should understand why sub_field :Opp do … end does not generates Opp module. However it’s easy to do so. Simply add Elixir. prefix instead of :, so:

defmodule MyLib do
  defmacro sub_field(name, do: block) do
    quote do
      defmodule unquote(name) do
        unquote(block)
      end
    end
  end
end

defmodule Example do
  import MyLib

  sub_field Elixir.Opp do
    def sample, do: IO.inspect(__MODULE__)
  end
end

Opp.sample()

You can also do that within macro using for example Module.concat/2

iex> Module.concat(Elixir, :Opp)
Opp

shahryarjb · August 12, 2023, 2:55pm

Thank you for the time you explain this, but I need to convert atom inside sub_field macro, and user just put an atom

Code:

  defmodule TestNestedStruct do
    use GuardedStruct

    guardedstruct do
      field(:title, String.t())
      field(:subject, String.t())

      sub_field(:oop, String.t(), enforce: true) do
        field(:title, String.t())
        field(:fam, String.t())
      end

      field(:site, String.t())
    end
  end

And

Error

error: MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop.__struct__/0 is undefined, cannot expand struct MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop. Make sure the struct name is correct. If the struct name exists and is correct but it still cannot be found, you likely have cyclic module usage in your code
  test/guarded_struct_test.exs:534: MishkaDeveloperToolsTest.GuardedStructTest."test nested macro field"/1

I think it just accept a Tuple for creating submodule

  defmacro sub_field(name, type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    name =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()

    module_name = Module.concat(Elixir, name)

    quote do
      defmodule unquote(module_name) do
        unquote(ast)
      end
    end
  end

If I put sub_field(Oop, String.t(), enforce: true) do, it works

I am improving my macro

zachallaun · August 12, 2023, 3:14pm

On my phone, so apologies if some of this is incorrect as I can’t test it, but I’d try the following:

defmacro sub_field(name, type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    name =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()

    quote unquote: false, bind_quoted: [name: name, ast: ast] do
      module_name = Module.concat(__MODULE__, name)

      defmodule unquote(module_name) do
        unquote(ast)
      end
    end
  end

I’d really need to test to be sure, and it can be a little tricky to follow with the nested unquote/bind_quotes bit, but essentially you need to access __MODULE__ in the calling module.

Eiji · August 12, 2023, 3:15pm

Take a look at this code for inspiration:

defmodule Example do
  def sample(module) when is_atom(module) do
    module |> Atom.to_string() |> Macro.camelize() |> String.to_atom()
  end
end

module = Example

[Opp, :Opp, :opp]
|> Enum.map(&Example.sample/1)
|> Enum.map(&Module.concat(module, &1))
|> IO.inspect()

# returns: [Example.Opp, Example.Opp, Example.Opp]

Note: I have tried Module.split/1, but it does not support non-Elixir modules (those having Elixir. prefix when changing to String).

Edit: I have forgot about Macro.camelize/1, so I have updated my code. Thanks @zachallaun!

zachallaun · August 12, 2023, 4:19pm

Credit where it’s due: I just copied it from @shahryarjb’s post above mine!

Eiji · August 12, 2023, 5:25pm

right, my bad

shahryarjb · August 12, 2023, 6:08pm

zachallaun:

defmacro sub_field(name, type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    name =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()

    quote unquote: false, bind_quoted: [name: name, ast: ast] do
      module_name = Module.concat(__MODULE__, name)

      defmodule unquote(module_name) do
        unquote(ast)
      end
    end
  end

I have this eror for this:

error: unquote called outside quote
  test/guarded_struct_test.exs:521: MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct (module)

shahryarjb · August 12, 2023, 6:11pm

Yes this place we can concat the module!! but when I use this inside my macro it does not work and has error.

  defmacro sub_field(name, _type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    name =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()

    module_name = Module.concat(Elixir, name)

    quote do
      defmodule unquote(module_name) do
        unquote(ast)
      end
    end
  end

Error

➜  mishka_developer_tools git:(master) ✗ mix test
Compiling 1 file (.ex)
error: MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop.__struct__/0 is undefined, cannot expand struct MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop. Make sure the struct name is correct. If the struct name exists and is correct but it still cannot be found, you likely have cyclic module usage in your code
  test/guarded_struct_test.exs:534: MishkaDeveloperToolsTest.GuardedStructTest."test nested macro field"/1


== Compilation error in file test/guarded_struct_test.exs ==
** (CompileError) test/guarded_struct_test.exs: cannot compile module MishkaDeveloperToolsTest.GuardedStructTest (errors have been logged)
    (stdlib 5.0.2) lists.erl:1706: :lists.mapfoldl_1/3
    (stdlib 5.0.2) lists.erl:1706: :lists.mapfoldl_1/3
    (ex_unit 1.15.1) expanding macro: ExUnit.Assertions.assert/1
    test/guarded_struct_test.exs:534: MishkaDeveloperToolsTest.GuardedStructTest."test nested macro field"/1

Eiji · August 12, 2023, 7:40pm

vs what your code do:
:oop → "oop" → "Oop" → Elixir.Oop

Something in your code tries to reference this long module where it should Oop or you should do other concatenation (not with Elixir, but for example a parent module i.e. __MODULE__). Since I have shared small example I have concatenated said module with Example module.

shahryarjb · August 12, 2023, 8:06pm

Ahh, Thank you yes you are right

  defmacro sub_field(name, _type, opts \\ [], do: block) do
    ast = register_struct(block, opts)

    name =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()

    %Macro.Env{module: mod} = __CALLER__
    module_name = Module.concat(mod, name)

    quote do
      defmodule unquote(module_name) do
        unquote(ast)
      end
    end
  end

but I think it just supports one level nested, because I use __CALLER__

I think it does not support

  defmodule TestNestedStruct do
    use GuardedStruct

    guardedstruct do
      field(:title, String.t())
      field(:subject, String.t())

      sub_field(:oop, String.t(), enforce: true) do
        field(:title, String.t())
        field(:fam, String.t())
        sub_field(:sop, String.t(), enforce: true) do
          field(:title, String.t())
        end
      end

      field(:site, String.t())
    end
  end

so I wont be able to fix it I create another post for it. thank you

Eiji · August 12, 2023, 8:14pm

__CALLER__ looks good for me and there should not be any problem. As always just an example to check what you worry about:

defmodule MyLib do
  defmacro my_macro(name, do: block) do
    module =
      name
      |> Atom.to_string()
      |> Macro.camelize()
      |> String.to_atom()
      |> then(&Module.concat(__CALLER__.module, &1))

    quote do
      defmodule unquote(module) do
        _ = unquote(block)
      end
    end
  end
end

defmodule A do
  import MyLib

  my_macro :b do
    my_macro :c do
      IO.inspect(__MODULE__)
    end
  end
end

The above code prints A.B.C.

shahryarjb · August 13, 2023, 7:22am

Hi again , I have a question, when I move my module and macro inside a test, it does not work, I think inside test it takes a time to compile and the functions are called faster than the macro

for example:

  test "nested macro field" do
    defmodule TestNestedStruct do
      use GuardedStruct

      guardedstruct do
        field(:title, String.t())
        field(:subject, String.t())

        sub_field(:oop, String.t(), enforce: true) do
          field(:title, String.t())
          field(:fam, String.t())

          sub_field(:soos, String.t(), enforce: true) do
            field(:fam, String.t())
          end
        end

        field(:site, String.t())
      end
    end

    IO.inspect(TestNestedStruct.__struct__())
    IO.inspect(TestNestedStruct.Oop.__struct__())
    IO.inspect(TestNestedStruct.Oop.__info__(:functions))
    IO.inspect(TestNestedStruct.Oop.Soos.__struct__())
    IO.inspect(TestNestedStruct.Oop.Soos.__info__(:functions))
    IO.inspect(TestNestedStruct.keys())

    assert %TestNestedStruct.Oop{
             fam: nil,
             title: nil
           } = TestNestedStruct.Oop.__struct__()
  end

The error:

error: MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop.__struct__/0 is undefined, cannot expand struct MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop. Make sure the struct name is correct. If the struct name exists and is correct but it still cannot be found, you likely have cyclic module usage in your code
  test/guarded_struct_test.exs:542: MishkaDeveloperToolsTest.GuardedStructTest."test nested macro field"/1

But if I move the module out of test macro, it works like:

  defmodule TestNestedStruct do
    use GuardedStruct

    guardedstruct do
      field(:title, String.t())
      field(:subject, String.t())

      sub_field(:oop, String.t(), enforce: true) do
        field(:title, String.t())
        field(:fam, String.t())

        sub_field(:soos, String.t(), enforce: true) do
          field(:fam, String.t())
        end
      end

      field(:site, String.t())
    end
  end

  test "nested macro field" do
    IO.inspect(TestNestedStruct.__struct__())
    IO.inspect(TestNestedStruct.Oop.__struct__())
    IO.inspect(TestNestedStruct.Oop.__info__(:functions))
    IO.inspect(TestNestedStruct.Oop.Soos.__struct__())
    IO.inspect(TestNestedStruct.Oop.Soos.__info__(:functions))
    IO.inspect(TestNestedStruct.keys())

    assert %TestNestedStruct.Oop{
             fam: nil,
             title: nil
           } = TestNestedStruct.Oop.__struct__()
  end

If i put the output of `struct` inside a variable, it print the output but it shows me this warning

....warning: MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop.__struct__/0 is undefined (module MishkaDeveloperToolsTest.GuardedStructTest.TestNestedStruct.Oop is not available or is yet to be defined)
  test/guarded_struct_test.exs:541: MishkaDeveloperToolsTest.GuardedStructTest."test nested macro field"/1

Eiji · August 13, 2023, 7:42am

It’s not a part of public API and therefore no answer guarantees you a working solution using it. Why cant you use %module{…} notation?

First of all why you do this? Much more common is to place it in test/fixtures/my_fixture.ex file …

There was some talk about this issue … I think it was about Elixir scripts i.e. exs files called like elixir my_script.exs. There was a question I think about ecto’s macros not working on same level where module is defined, but working inside some function … Somebody from Elixir’s core team (most probably José Valim) commented it and that it’s known limitation.

Create sub module with atom name

For example:

Code:

Error

Error

for example:

But if I move the module out of test macro, it works like:

If i put the output of __struct__ inside a variable, it print the output but it shows me this warning

If i put the output of `struct` inside a variable, it print the output but it shows me this warning