Elixir Cheatsheet

Quick reference for Elixir basics — structures, functions, loops, and concurrency.

Data Structures

Structure	Syntax	Notes
List	`[1, 2, 3]`	Linked list, prepend is O(1)
Tuple	`{1, :ok, "msg"}`	Fixed-size, indexed
Map	`%{a: 1, b: 2}`	Key-value
MapSet	`MapSet.new([1, 2])`	Unique values
Keyword	`[a: 1, b: 2]`	List of 2-tuples, keys are atoms

Functions

# Named function
def greet(name) do
  "Hello, #{name}"
end

# Pattern matching in args
def handle({:ok, result}), do: result
def handle({:error, reason}), do: {:error, reason}

# Default arguments
def connect(host \\ "localhost", port \\ 3000) do
  "#{host}:#{port}"
end

# Anonymous function
square = fn x -> x * x end
square.(4)  # => 16

# Pipe operator
"hello"
|> String.upcase()
|> String.slice(0..2)

# Guards
def adult?(age) when age >= 18, do: true
def adult?(_), do: false

Loops & Iteration

# Enum.each (side effects)
Enum.each([1, 2, 3], &IO.puts/1)

# Enum.map
doubled = Enum.map([1, 2, 3], &(&1 * 2))

# Enum.filter
evens = Enum.filter(1..10, &rem(&1, 2) == 0)

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

# Comprehension
for n <- 1..5, n > 2, do: n * n

# Recursion (idiomatic)
defmodule Loop do
  def each([]), do: :ok
  def each([h | t]) do
    IO.puts(h)
    each(t)
  end
end

Concurrency

# Spawn a process
pid = spawn(fn -> IO.puts("hello from process") end)

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

# Task.async_stream (parallel map)
results = Task.async_stream(collection, &process/1, max_concurrency: 4)
|> Enum.to_list()

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

# GenServer (OTP server)
defmodule Counter do
  use GenServer
  def init(_), do: {:ok, 0}
  def handle_call(:get, _from, count), do: {:reply, count, count}
  def handle_cast(:inc, count), do: {:noreply, count + 1}
end

# ETS (in-memory store)
:ets.new(:cache, [:set, :public, :named_table])
:ets.insert(:cache, {:key, "value"})
:ets.lookup(:cache, :key)