Elixir

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.ex, .exs

Registry names

elixir

Recorded symbols

modules · functions · typespecs

Relationship types this analyzer constructs

10 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

10 constructed, 4 not constructed. All 4 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• Kernel builtins are excluded from the call graph on purpose, and the list holds 73 names: they exist in every module and would bury every real edge underneath them. The same rule drops the qualified spelling, so Kernel.length is as silent as length.
• Macros are not expanded, so an unqualified call through a bare import Foo — or through an import carrying an :except list — cannot be confirmed to come from where a reader would guess. Those calls stay unresolved instead of being attributed.
• Everything inside a quote do block is macro-generated data, so a name appearing only there publishes no symbol and no call edge. The exception is an unquote argument, which executes at expansion time and is walked.

Every line above was written against Elixir’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .ex, .exs. Everything below is about where those files actually sit in a working repository.

• A mix umbrella is a tree of applications, so a protocol and its implementations routinely live in different ones.
• A behaviour is a contract the module then satisfies, and its callbacks are ordinary defs carrying a marker.
• Arity is part of a function's identity, so a search for one name has to account for the clause that introduced it.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which modules implement this protocol?
2. Which callbacks does this behaviour declare?
3. Is this module a GenServer, and which of its functions are the callbacks?
4. Which fields does this struct carry?

What the analyzer sees in code like this

defmodule MyApp.OrderBook do          # bb records: module MyApp.OrderBook
  @behaviour GenServer               # bb records: implements GenServer

  defstruct bids: [], total: 0       # bb records: struct with fields bids, total

  def place(o, n) when n > 0 do      # bb records: function place/2, with its guard
    Acct.charge(o, n)                # bb records: a call resolved through the alias
  end
end

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Functional & declarative — the count beside each name is how many relationship types that family’s analyzer constructs.

• Clojure11 types
• Haskell12 types
• Scala11 types
• Erlang9 types
• F#11 types
• Clean9 types
• Nim12 types
• Julia11 types
• MATLAB11 types
• Solidity11 types