Elixir Cheat Sheet

IO.puts("Hello, World!")

# Single line comment

@moduledoc """
Module documentation
"""

elixir script.exs     # Run script
iex                   # Interactive shell
iex -S mix            # Shell with project

mix new my_app
mix new my_app --sup  # With supervisor

42          # Integer
3.14        # Float
0b1010      # Binary (10)
0o777       # Octal (511)
0xFF        # Hex (255)

:ok
:error
:hello_world
true        # Same as :true
false       # Same as :false
nil         # Same as :nil

"Hello, World!"
"Hello, #{name}!"     # Interpolation
~s(String with "quotes")

'hello'     # List of integers
[104, 101, 108, 108, 111]  # Same

true and false    # true
true or false     # true
not true          # false

[1, 2, 3]
[1 | [2, 3]]        # Prepend
[1, 2] ++ [3, 4]    # Concat
[1, 2, 3] -- [2]    # Subtract
hd([1, 2, 3])       # 1 (head)
tl([1, 2, 3])       # [2, 3] (tail)

{:ok, "value"}
{:error, reason}
elem({:a, :b, :c}, 1)  # :b
put_elem(tuple, 1, :x)

%{name: "John", age: 30}
%{"key" => "value"}
map[:name]          # "John"
map.name            # "John" (atom keys)
%{map | age: 31}    # Update

[name: "John", age: 30]
[{:name, "John"}, {:age, 30}]  # Same

defmodule User do
  defstruct [:name, :age]
end

%User{name: "John", age: 30}

x = 1
{a, b} = {1, 2}
[head | tail] = [1, 2, 3]
%{name: name} = %{name: "John"}

x = 1
^x = 1      # Match against value of x
^x = 2      # ** (MatchError)

{_, second} = {1, 2}
[head | _] = [1, 2, 3]

case value do
  x when x > 0 -> "positive"
  x when x < 0 -> "negative"
  _ -> "zero"
end

case value do
  {:ok, result} -> result
  {:error, _} -> "error"
  _ -> "unknown"
end

cond do
  x > 10 -> "big"
  x > 5 -> "medium"
  true -> "small"
end

if condition do
  "true"
else
  "false"
end

unless condition, do: "false"

with {:ok, a} <- fetch_a(),
     {:ok, b} <- fetch_b(a) do
  {:ok, a + b}
else
  {:error, reason} -> {:error, reason}
end

defmodule Math do
  def add(a, b) do
    a + b
  end

  def add(a, b, c), do: a + b + c
end

defp helper(x) do
  x * 2
end

add = fn a, b -> a + b end
add.(1, 2)    # 3

# Shorthand
add = &(&1 + &2)
add.(1, 2)    # 3

def greet(name \\ "World") do
  "Hello, #{name}!"
end

def factorial(0), do: 1
def factorial(n), do: n * factorial(n - 1)

"hello world"
|> String.upcase()
|> String.split()
# ["HELLO", "WORLD"]

[1, 2, 3]
|> Enum.map(&(&1 * 2))
|> Enum.filter(&(&1 > 2))
|> Enum.sum()
# 10

Enum.map([1, 2, 3], fn x -> x * 2 end)
# [2, 4, 6]

Enum.filter([1, 2, 3, 4], &(rem(&1, 2) == 0))
# [2, 4]

Enum.reduce([1, 2, 3], 0, &(&1 + &2))
# 6

Enum.find([1, 2, 3], &(&1 > 1))
# 2

Enum.all?([2, 4, 6], &(rem(&1, 2) == 0))  # true
Enum.any?([1, 2, 3], &(&1 > 2))           # true

Enum.sort([3, 1, 2])          # [1, 2, 3]
Enum.sort([3, 1, 2], :desc)   # [3, 2, 1]

pid = spawn(fn -> IO.puts("Hello") end)
Process.alive?(pid)

send(self(), {:hello, "world"})

receive do
  {:hello, msg} -> IO.puts(msg)
after
  1000 -> IO.puts("timeout")
end

task = Task.async(fn -> expensive_work() end)
result = Task.await(task)

{:ok, agent} = Agent.start_link(fn -> 0 end)
Agent.get(agent, & &1)          # 0
Agent.update(agent, &(&1 + 1))