The Elixir Cheatsheet.

asdf plugin add erlang https://github.com/asdf-vm/asdf-erlang.git
asdf plugin add elixir https://github.com/asdf-vm/asdf-elixir.git
asdf install erlang latest
asdf install elixir latest
asdf global elixir latest

elixir --version
# Erlang/OTP 28 [erts-...] ...
# Elixir 1.20.4 (compiled with Erlang/OTP 28)

# Comments start with #
IO.puts("Hello, World!")
name = "Elixir"
IO.puts("Hello, #{name}!")   # interpolation with #{…}

person = %{name: "Ada", lang: :elixir}
IO.inspect(person, label: "person")

mix new hello --sup          # --sup generates a supervision tree
cd hello
mix test                     # the scaffold ships with a passing test
mix run -e 'IO.puts("hi")'   # run one expression
MIX_OS_DEPS_COMPILE_PARTITION_COUNT=4 mix deps.compile  # parallel deps (1.19+)

defmodule Hello.MixProject do
  use Mix.Project

  def project do
    [
      app: :hello,
      version: "0.1.0",
      elixir: "~> 1.20",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [extra_applications: [:logger], mod: {Hello.Application, []}]
  end

  defp deps, do: []
end

defmodule Greet do
  @moduledoc "Docs for the whole module."
  @punct "!"                # module attribute = compile-time constant

  @doc "Greets a person by name."
  def greet(name, lang \\ :en) do
    salutation(lang) <> String.capitalize(name) <> @punct
  end

  defp salutation(:en), do: "Hello, "
  defp salutation(:pt), do: "Ola, "
end

Greet.greet("ada")          #=> "Hello, Ada!"
Greet.greet("ada", :pt)     #=> "Ola, Ada!"

IO.inspect(Greet.greet("ada"), label: "greet/1")
IO.inspect(Greet.greet("ada", :pt), label: "greet/2")

map1 = %{name: "Ada", role: :admin}

map2 = Map.put(map1, :role, :user)   # returns a NEW map

map1
#=> %{name: "Ada", role: :admin}     # map1 is untouched
map2
#=> %{name: "Ada", role: :user}

# Idiomatic style: rebind the same name once the old
# value has no further use
user = %{name: "Ada"}
user = Map.put(user, :active, true)

IO.inspect(map1, label: "map1 (untouched)")
IO.inspect(map2, label: "map2 (new)")
IO.inspect(user, label: "rebound")

iex> 1 + 2 * 3
7
iex> 10 / 4              # / always returns a float
2.5
iex> div(10, 4)          # truncated integer division (rem/2 = remainder)
2
iex> [1, 2] ++ [3, 4]    # list concatenation...
[1, 2, 3, 4]
iex> [1, 2, 3, 4] -- [2, 4]   # ...and difference
[1, 3]
iex> "foo" <> "bar"      # binary (string) concatenation
"foobar"
iex> :elixir in [:erlang, :elixir]   # membership
true
iex> 5 in 1..10          # works on ranges too
true

IO.puts(1 + 2 * 3)
IO.puts(10 / 4)
IO.puts(div(10, 4))
IO.inspect([1, 2] ++ [3, 4])
IO.inspect([1, 2, 3, 4] -- [2, 4])
IO.puts("foo" <> "bar")
IO.inspect(:elixir in [:erlang, :elixir])
IO.inspect(5 in 1..10)

name = "Ada"

"Hello, #{name}!"        # interpolation — runs String.Chars.to_string/1
"Hello, " <> name        # concatenation (binaries only)

sql = """
  SELECT *
  FROM users
  """                    # heredoc: multi-line, indentation trimmed

String.upcase("elixir")  #=> "ELIXIR"
String.length("héllo")   #=> 5   (graphemes)
byte_size("héllo")       #=> 6   (bytes: é is 2 in UTF-8)

IO.inspect("Hello, #{name}!", label: "interpolated")
IO.inspect(String.upcase("elixir"), label: "upcase")
IO.inspect(String.length("héllo"), label: "graphemes")
IO.inspect(byte_size("héllo"), label: "bytes")

iex> 1_000_000             # underscores for readability
1000000
iex> 0b1010                # base 2
10
iex> 0o777                 # base 8
511
iex> 0xFF                  # base 16
255
iex> ?a                    # codepoint of a character
97
iex> 10 / 4                # / is float division
2.5
iex> div(10, 4)            # truncated integer division
2
iex> rem(-10, 3)           # remainder keeps the dividend's sign
-1

IO.inspect([1_000_000, 0b1010, 0o777, 0xFF, ?a])
IO.inspect([10 / 4, div(10, 4), rem(-10, 3)])

iex> Integer.ceil_div(7, 2)     # division rounded up (since v1.20)
4
iex> Integer.popcount(255)      # count of set bits (since v1.20)
8
iex> Float.round(3.14159, 2)
3.14
iex> Integer.parse("42 steps")  # leading integer + leftover
{42, " steps"}
iex> String.to_integer("42")
42
iex> String.to_float("2.5")     # requires a dot — "2" raises
2.5

IO.inspect([Integer.ceil_div(7, 2), Integer.popcount(255), Float.round(3.14159, 2)])
IO.inspect([Integer.parse("42 steps"), String.to_integer("42"), String.to_float("2.5")])

iex> :ok                      # an atom's name is its value
:ok
iex> :ok == :error
false
iex> String == :"Elixir.String"   # module aliases are atoms too
true
iex> to_string(:hello)            # atoms convert to strings
"hello"
iex> :"with spaces"               # quoted atoms
:"with spaces"

IO.inspect([:ok == :error, String == :"Elixir.String", to_string(:hello)])

iex> String.to_atom("user_" <> "1")       # creates a NEW atom
:"user_1"
iex> String.to_existing_atom("user_1")    # only if it already exists
:"user_1"

# The one call that cannot fail politely has to be rescued:
try do
  String.to_existing_atom("never_created_123")
rescue
  e in ArgumentError -> IO.puts("rescued: #{Exception.message(e)}")
end

iex> true and is_atom(:ok)          # and/or demand booleans
true
iex> nil || false || 0 || "default" # only nil and false are falsy
0
iex> nil && :never_evaluated        # &&/|| accept any value
nil
iex> is_nil(nil)
true
iex> not is_nil(%{})                # there is no nil?/1 in Elixir 1.20
false

IO.inspect([
  true and is_atom(:ok),
  nil || false || 0 || "default",
  nil && :never_evaluated,
  is_nil(nil),
  not is_nil(%{}),
])

try do
  nil and :never_evaluated
rescue
  e -> IO.puts("and demands booleans: " <> Exception.message(e))
end

iex> ~s(a #{1 + 1} b)          # ~s: string, interpolates
"a 2 b"
iex> ~S(a #{1 + 1} b)          # uppercase: fully literal
"a \#{1 + 1} b"
iex> ~w(see you soon)a         # words; modifier a/s/c = atoms/strings/charlists
[:see, :you, :soon]
iex> ~r/ab+c/                  # regex — see the Regex module
~r/ab+c/
iex> ~c(a charlist)
'charlist'

IO.inspect([~s(a #{1 + 1} b), ~S(a #{1 + 1} b), ~w(see you soon)a, ~c(a charlist)])

iex> date = ~D[2026-06-03]            # Date struct (no time, no zone)
iex> time = ~T[08:30:00.500]          # Time struct
iex> naive = ~N[2026-06-03T08:30:00]  # NaiveDateTime (no zone)
iex> dt = ~U[2026-06-03T08:30:00Z]    # DateTime, always UTC
iex> Date.shift(date, month: 1)       # calendar-safe shift (since v1.17)
~D[2026-07-03]
iex> DateTime.compare(dt, ~U[2026-12-01T00:00:00Z])
:lt
iex> to_timeout([minute: 5])          # duration -> milliseconds
300000

IO.inspect([
  Date.shift(~D[2026-06-03], month: 1),
  DateTime.compare(~U[2026-06-03T08:30:00Z], ~U[2026-12-01T00:00:00Z]),
  to_timeout([minute: 5]),
])

iex> list = [3, 1, 2]
iex> [head | tail] = list      # head = first element, tail = rest
iex> {head, tail}
{3, [1, 2]}
iex> hd(list)                  # first element (tl/1 = rest)
3
iex> [0 | list]                # prepend: O(1)
[0, 3, 1, 2]
iex> list ++ [4]               # append: O(n) — walks every node
[3, 1, 2, 4]
iex> [1, 2, 3, 4] -- [2, 4]    # difference
[1, 3]
iex> length(list)              # O(n) — counts node by node
3
iex> Enum.at(list, 2)          # O(n) — random access walks the list
2

IO.inspect({head, tail})
IO.inspect([hd(list), length(list), Enum.at(list, 2)])
IO.inspect([0 | list])
IO.inspect(list ++ [4])
IO.inspect([1, 2, 3, 4] -- [2, 4])

iex> tuple = {:ok, 42}
iex> elem(tuple, 0)
:ok
iex> elem(tuple, 1)
42
iex> put_elem(tuple, 1, 43)   # returns a NEW tuple
{:ok, 43}
iex> tuple_size(tuple)        # O(1) — size is stored, unlike length/1
2
iex> {:error, reason} = {:error, :enoent}
iex> reason
:enoent

IO.inspect({elem(tuple, 0), elem(tuple, 1)})
IO.inspect(put_elem(tuple, 1, 43))
IO.inspect(tuple_size(tuple))
IO.inspect(reason)

iex> kw = [name: "Ada", role: :admin]
iex> kw == [{:name, "Ada"}, {:role, :admin}]   # sugar for tuples
true
iex> [name: "Ada", name: "Grace"]              # ordered, duplicates allowed
[name: "Ada", name: "Grace"]
iex> Keyword.get(kw, :missing, :default)
:default
iex> Keyword.fetch(kw, :role)
{:ok, :admin}
iex> Keyword.keys(kw)
[:name, :role]

IO.inspect(kw == [{:name, "Ada"}, {:role, :admin}])
IO.inspect([
  Keyword.get(kw, :missing, :default),
  Keyword.fetch(kw, :role),
  Keyword.keys(kw),
])

defmodule Client do
  def connect(host, opts \\ []) do
    port = Keyword.get(opts, :port, 4000)
    {host, port}
  end
end

IO.inspect(Client.connect("db.local"))                    # opts = []
IO.inspect(Client.connect("db.local", port: 5433, timeout: 5_000))
# a trailing bracket-less keyword list becomes the LAST argument

iex> m = %{name: "Ada", role: :admin}    # atom keys: shorthand
iex> m.name                              # dot access: only for known atom keys
"Ada"
iex> m[:role]                            # bracket syntax: any key type
:admin
iex> mixed = %{"a" => 1, :b => 2, 3 => "c"}   # => syntax: any key type
iex> Map.fetch!(m, :name)                # raises KeyError when missing
"Ada"
iex> Map.get(m, :missing, "fallback")
"fallback"
iex> Map.fetch(m, :missing)              # :error instead of raising
:error

IO.inspect([m.name, m[:role], Map.fetch!(m, :name)])
IO.inspect([Map.get(m, :missing, "fallback"), Map.fetch(m, :missing)])

iex> set = MapSet.new([1, 2, 2, 3])   # duplicates collapse
iex> MapSet.member?(set, 2)
true
iex> MapSet.union(set, MapSet.new([3, 4]))
#MapSet<[1, 2, 3, 4]>
iex> MapSet.intersection(set, MapSet.new([2, 3, 9]))
#MapSet<[2, 3]>

IO.inspect(MapSet.member?(set, 2))
IO.inspect(MapSet.union(set, MapSet.new([3, 4])))
IO.inspect(MapSet.intersection(set, MapSet.new([2, 3, 9])))

defmodule User do
  @enforce_keys [:name]
  defstruct name: nil, role: :member, tags: []
end

defmodule Demo do
  def run do
    user = %User{name: "Ada"}          # missing :name = compile error
    admin = %User{user | role: :admin} # update syntax: existing fields only
    IO.inspect(user.role)
    IO.inspect(admin)
  end
end

Demo.run()
# %User{user | nope: 1}              # unknown key fails to compile (v1.18+)

iex> range = 1..10              # inclusive, ascending
iex> 5 in range
true
iex> Enum.map(1..3, &(&1 * 10))
[10, 20, 30]
iex> Enum.sum(1..100//2)        # step: 1, 3, 5, ..., 99
2500
iex> Enum.to_list(10..1//-1)    # descending: explicit negative step
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
iex> Range.disjoint?(1..5, 6..10)
true
iex> Range.disjoint?(1..5, 5..10)
false

IO.inspect([
  5 in range,
  Enum.map(1..3, &(&1 * 10)),
  Enum.sum(1..100//2),
  Range.disjoint?(1..5, 6..10),
  Range.disjoint?(1..5, 5..10),
])
IO.inspect(Enum.to_list(10..1//-1))

iex> {a, b} = {1, 2}          # tuples destructure element-wise
iex> a + b
3
iex> [x, y, z] = [1, 2, 3]    # lists destructure positionally
iex> x + y + z
6
iex> {x, x} = {1, 1}          # repeated vars must be equal
iex> %{age: age} = %{age: 30}   # partial match: take the keys you need

IO.inspect(a + b)
IO.inspect(x + y + z)
IO.inspect(age)

# A repeated variable is a match condition, not a rebind:
try do
  {x, x} = {1, 2}
rescue
  e -> IO.puts("rescued: " <> Exception.message(e))
end

iex> [h | t] = [1, 2, 3]
iex> {h, t}
{1, [2, 3]}
iex> %{name: name} = %{name: "Ada", age: 36}   # partial match!
iex> name
"Ada"
iex> %{user: %{name: name}} = %{user: %{name: "Grace", admin: true}}
iex> name
"Grace"
iex> {:ok, [first | _rest]} = {:ok, [1, 2, 3]}
iex> first
1

IO.inspect({h, t})
IO.inspect(name)   # rebound by the nested match above
IO.inspect(first)

iex> expected = 2
iex> {^expected, actual} = {2, 9}     # ^ reads the existing binding
iex> {expected, actual}
{2, 9}

IO.inspect({expected, actual})

# A pin that does not match is a MatchError, not a rebind:
try do
  {^expected, _} = {3, 4}
rescue
  e -> IO.puts("rescued: " <> Exception.message(e))
end

defmodule Math do
  def sign(n) when n > 0, do: :positive    # guard refines the clause
  def sign(0), do: :zero                   # literal pattern
  def sign(n) when n < 0, do: :negative
  def sign(_), do: {:error, :not_a_number} # catch-all last
end

defmodule Demo do
  def run do
    IO.inspect([Math.sign(3), Math.sign(0), Math.sign(-2), Math.sign("x")])

    case File.read("mix.exs") do
      {:ok, content} -> {:read, byte_size(content)}
      {:error, :enoent} -> :missing
      {:error, reason} -> {:failed, reason}    # cover every shape
    end
    |> IO.inspect(label: "case")
  end
end

Demo.run()

iex> <<a, b>> = <<1, 2>>        # each segment defaults to 8 bits
iex> {a, b}
{1, 2}
iex> <<len, rest::binary>> = <<3, 97, 98, 99>>
iex> {len, rest}
{3, "abc"}
iex> <<a::8, b::16, c::8>> = <<1, 0, 5, 9>>   # bit-sized segments
iex> {a, b, c}
{1, 5, 9}
iex> <<ch::utf8>> = "é"         # one UTF-8 codepoint (2 bytes here)
iex> ch
233
iex> "Bearer " <> token = "Bearer abc123"     # prefix match on strings
iex> token
"abc123"
iex> <<w1::binary-size(2), _::binary>> = "elixir"
iex> w1
"el"

IO.inspect({a, b})
IO.inspect({len, rest})
IO.inspect(ch)
IO.inspect(token)
IO.inspect(w1)

defmodule PNG do
  @magic <<137, 80, 78, 71, 13, 10, 26, 10>>   # PNG file signature

  def parse(<<@magic::binary, width::32, height::32, _rest::binary>>) do
    {:ok, width, height}
  end

  def parse(_other), do: {:error, :not_a_png}
end

PNG.parse(<<
  137, 80, 78, 71, 13, 10, 26, 10,   # signature
  0, 0, 8, 0,                        # width  = 2048
  0, 0, 4, 80                        # height = 1104
>>)
|> IO.inspect()   #=> {:ok, 2048, 1104}

PNG.parse("not a png")
|> IO.inspect(label: "no match")

defmodule Text do
  # public — callable from other modules as Text.format/2
  def format(lines, width) do
    lines
    |> Enum.join(" ")
    |> wrap(width)
  end

  # private — visible only inside this module
  defp wrap(string, width) when byte_size(string) <= width, do: string
  defp wrap(string, width), do: String.slice(string, 0, width) <> "…"
end

Text.format(["elixir", "rocks"], 40)
|> IO.inspect()   #=> "elixir rocks"

defmodule Join do
  def join(list, sep \\ ", "), do: Enum.join(list, sep)
end

Join.join(["a", "b", "c"])
|> IO.inspect(label: "join/1")

Join.join(["a", "b", "c"], " + ")
|> IO.inspect(label: "join/2")

double = fn x -> x * 2 end
double.(4)          #=> 8 — call with a DOT

# multiple clauses, matched top-down, guards allowed
classify = fn
  x when x < 0 -> :negative
  0 -> :zero
  _x -> :positive
end
classify.(-5)       #=> :negative

# closures capture by value — data is immutable
n = 10
add_n = fn x -> x + n end
n = 0               # rebinding outside does not change the closure
add_n.(5)           #=> 15

IO.inspect([double.(4), classify.(-5), add_n.(5)])

transform = fn fun, x -> fun.(fun.(x)) end
transform.(&(&1 * 3), 2)          #=> 18

# then/2 threads a value through a single function
port =
  System.get_env("ELIXIR_CHEATS_PORT")   # unset -> nil
  |> then(fn
    nil -> "4000"
    port -> port
  end)
  |> String.to_integer()

# functions building functions — closures as factories
prefix = fn tag -> fn msg -> "[#{tag}] #{msg}" end end
log = prefix.("info")
log.("started")                   #=> "[info] started"

IO.inspect(port)
IO.inspect(log.("started"))

defmodule Profile do
  def city(map) do
    with {:ok, user} <- Map.fetch(map, :user),
         {:ok, address} <- Map.fetch(user, :address),
         {:ok, city} <- Map.fetch(address, :city) do
      {:ok, city}
    else
      :error -> {:error, :missing_key}   # Map.fetch fails with :error
      other -> other                     # any other miss, passed through
    end
  end
end

Profile.city(%{user: %{address: %{city: "Tokyo"}}})
#=> {:ok, "Tokyo"}

IO.inspect(Profile.city(%{user: %{address: %{city: "Tokyo"}}}))
IO.inspect(Profile.city(%{}))   # the else branch normalises the miss