Elixir 1.20: Full Type Inference, Zero Annotations Required

Elixir 1.20 arrives with something the language has spent three years building toward: full type inference across every construct, with no annotations required. RC.6 landed on May 21. The compiler now understands your functions, guards, maps, and pattern matching well enough to warn you when your code is wrong — without a single type signature in your source.

This is the “finally” release. The one where three years of theoretical groundwork becomes something you feel on the next mix compile.

What “Full Inference” Actually Means

Previous Elixir versions could infer types from patterns — if you matched on %{name: name}, the compiler knew you expected a map with a :name key. Elixir 1.20 goes further: it infers from usage.

Take this unremarkable function:

def user_age_to_string(user) do
  Integer.to_string(user.age)
end

In 1.19, the type system shrugged. In 1.20, it constructs the type %{..., age: integer()} -> binary() from the function body alone. The leading ... means other keys are fine — the compiler only cares about :age being present and numeric. Call that function with %{name: "Alice"} and you get a compile-time warning. No spec, no annotation, no ceremony.

Guards are now fully inferred too. when is_list(x) and is_integer(y) teaches the compiler that x is a list and y is an integer through the rest of that clause. Map key mutations are tracked through the Map module — the system knows when you add, update, or remove a key, and warns when you later access one that has been proven absent.

How We Got Here: Four Versions, One Plan

This was not a pivot. The Elixir core team published a 15-month roadmap in January 2026 and executed it version by version:

• 1.17 — Set-theoretic type foundation; pattern matching types only
• 1.18 (December 2024) — Type checking of function calls; tuples and lists added
• 1.19 (October 2025) — Anonymous functions and protocol checking; 4x faster compilation for large projects
• 1.20 (May 2026) — Everything: closures, with, for, whole-program inference across clauses and dependencies

The trajectory is worth appreciating. Each version closed specific gaps. 1.20 does not just add features — it completes the inference layer so the team can build on top of it.

The Honest Caveat: False Positives Exist

The first release candidates were transparent about this: “Do not change your programs based on these warnings yet.” RC.1 through RC.3 produced meaningful false positives, particularly around protocol implementations and complex map patterns. The team targeted “few or none” false positives by stable release, and RC.6 (May 21) reflects considerable progress.

That said, if your codebase relies heavily on dynamic dispatch or complex protocol hierarchies, expect some spurious warnings in the first weeks after upgrading. Treat new warnings as clues, not verdicts. Most will point at real issues. The tooling to suppress specific warnings exists — use it selectively rather than silencing everything.

The Ecosystem Signal: Ecto Moved First

Here is what tells you these warnings matter: Ecto — Elixir’s primary database layer — committed type warning fixes before 1.20 reached stable. Phoenix 1.8’s release candidate similarly updated ahead of the release. When library authors are cleaning up against a pre-release type checker, it means two things. First, the warnings are surfacing real code issues, not just theoretical edge cases. Second, the upgrade path for most Phoenix and Ecto applications will be cleaner than you expect.

The community did not wait to be told this matters. That’s the signal.

What Comes After 1.20

The type system roadmap does not stop at inference. The next targets:

• v1.21 — Typed Structs: Define field types directly inside defstruct. The compiler enforces them.
• v1.22 — Type Signatures: A syntax for expressing function contracts that replaces @spec for static analysis — annotations, when you want them.

The design philosophy is deliberate: prove soundness at the inference layer first, before exposing user-facing type APIs. Elixir is not trying to become Haskell. It is trying to give dynamic-language developers the bugs-caught-at-compile-time experience without demanding they restructure their code to get there.

Python went the annotation route — PEP 484, mypy, Pyright, gradual adoption across a decade. Elixir went the other direction: infer everything, annotate optionally. For a language built on the BEAM’s pattern matching model, inference from usage is the right fit.

Upgrade Path

Install via asdf install elixir 1.20.0 or mise use elixir@1.20.0 once stable ships. Run mix compile and read what surfaces. If you are using Ecto and Phoenix, most of the major library warnings are already fixed upstream. Requires Erlang/OTP 27 minimum — OTP 29 is supported and recommended for new projects.

Elixir 1.20 does not ask you to write types. It just starts telling you where your assumptions are wrong. That’s the deal — and for most codebases, it is a good one.