There are some tools and techniques that allow to do things comparable to what Java/.NET reflection APIs provide.

• for inspecting current loaded/running BEAM applications use functions from elixir Application module (e.g. Application.all_started/0)
• for working with loaded/complied module use erlang :code, e.g. `:code.all_loaded/0’
• to fetch all functions/macros/callbacks of a given module use builtin functions __info__/1, module_info/0,1, `behaviour_info/1
• Protocols provide some info by means of __protocol__/1, impl_for/1, impl_for!/1 functions
• Struct can be converted to map with Map.from_struct/1 - use that to inspect/iterate over fields
• Map can be converted to struct by putting special key e.g. Map.put(my_map, :__struct__, MyModule)
• It is possible to generate code and compile modules on the fly (look into Code)
• module alias is just an atom, you can generate it in the runtime by format string expressions, e.g. :"Elixir.My.#{prefix}Module"
• you can invoke any function with apply
• use Code.fetch_docs to query documentation
• use Code.Typespec.fetch_specs/callbacks/types to query dialyzer specs (warning - private API)
• use macros and Macro.pre/postwalk to generate/transform AST

The closest thing I think of to Java reflection is the __info__/1 (https://hexdocs.pm/elixir/1.8.1/Module.html#c:info/1) function defined on each module. It lets you find out what function/arity are exported by each module, plus other metadata.

Reflection in Java is generally focused on classes, and since Elixir does not have classes or objects, there is nothing particularly equivalent to Java reflection at all.

Keep in mind, reflection is a tool that exists to solve problems a particular way. Elixir is an entirely different approach to programming than Java, and so it has entirely different tools. The best way to learn Elixir is on its own terms, and not try too hard to find Java equivalents.

There aren’t really any successfully developed or adopted solutions for runtime reflection/inspection of Elixir modules, and in most cases we would favor compile-time metaprogramming. This might be done with macros or with just simple uses of quote/unquote. Chris McCord’s book is excellent here and does not suffer from its age as these facilities haven’t changed much over time since it was published.

This particular piece works fine as-is, but is safest to do with Module.concat/1 or better still, Module.safe_concat/1 or their /2 variants.