Types can be read from the module’s bytecode like the following at compile-time:

defmodule MyModule do
  @type one_type :: atom()
  @opaque another_type :: integer()

  @after_compile {MyModule, :_collect_types}

  def _collect_types(_env, bytecode) do
    {:ok, types} = Code.Typespec.fetch_types(bytecode)

    Enum.map(types, fn {kind, type} ->
      type_ast = Code.Typespec.type_to_quoted(type)

      type_ast
      |> Macro.to_string()
      |> IO.inspect(label: kind)
    end)
  end
end

it prints:

opaque: "another_type() :: integer()"
type: "one_type() :: atom()"

You cannot. I have asked for such thing on the Erlang Issue Tracker and IRC and there is no way to achieve what you want. The only solution is to manually store 3rd element of the tuple returned by defmodule and use that as a BEAM data.

Good to know. It seems OTP has no public interface to get in-memory modules yet.

So I’ve solved my problem by simply collecting types from the bytecode with @after_compile {module, fun} hook because the library should be used explicitly in the modules anyway.

The other way to get bytecodes is a {:on_module, bytecode, :none} compilation tracer introduced in Elixir v1.13.0. The tracer can be added to the elixir compiler configuration dynamically from a custom mix compile task that should go first in compilers list in project’s mix.exs file.

Hi @IvanR! Thanks for asking this — I’m also wondering about the same. Do you have any code examples you could share with details on how specifically you can get the types with an @after_compile hook? I understand the general idea but I’m not clear how to specifically do it in code.