Reflection in Elixir

There are neither objects nor classes in elixir, so I’m not sure what exactly you’re looking for. Data in elixir is just data. For inspecting processes you might want to look at :sys.

Whoops.. as you see im pretty new in Elixir. Thanks for your answer. Is this the most equivalent to reflection in Java?

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.

The closest thing I think of to Java reflection is the __info__/1 (Module — Elixir v1.8.1) function defined on each module. It lets you find out what function/arity are exported by each module, plus other metadata.

Ecto has some reflection with

__schema__

For example…

iex> Accounts.User.__schema__ :fields
[:id, :name, :email, :password_hash, :is_admin, :customer_info, :inserted_at,
 :updated_at]
iex> Accounts.User.__schema__ :type, :id
:id
iex> Accounts.User.__schema__ :type, :name
:string
iex> Accounts.User.__schema__ :associations
[]

The list is not complete…

        def __schema__(:prefix)
        def __schema__(:source)
        def __schema__(:fields)
        def __schema__(:query_fields)
        def __schema__(:primary_key)
        def __schema__(:hash)
        def __schema__(:read_after_writes)
        def __schema__(:autogenerate_id)
        def __schema__(:autogenerate)
        def __schema__(:autoupdate)
        ...

This works for Ecto schema, but not for struct

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

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.

The closest thing to reflection in Erlang/Elixir (and all BEAM languages) are the apply/2 and apply/3 functions.

That being said, I completely agree with @benwilson512 – learn functional programming and Elixir itself and you will find several alternatives that might even work better for your use case.