Folha de dicas da Linguagem de Programação Elixir

Elixir e uma linguagem funcional dinamica para criacao de aplicacoes escalaveis e tolerantes a falhas na maquina virtual do Erlang (BEAM).

🔗 Relacionado: Folha de dicas de Metaprogramacao em Elixir · Folha de dicas do Absinthe GraphQL · Folha de dicas do Phoenix Framework

Primeiros passos (Getting Started)

# hello.exs
defmodule Greeter do
  def greet(name) do
    message = "Hello, " <> name <> "!"
    IO.puts(message)
  end
end

Greeter.greet("world")

Executar via CLI do Elixir:

elixir hello.exs
# => Hello, world!

Variaveis e imutabilidade (Variables & Immutability)

age = 23
age = 24 # Reatribuicao (nao altera o valor original na memoria)

Mapas (Maps)

user = %{
  name: "John",
  city: "Melbourne"
}

IO.puts("Hello, " <> user.name)

Listas (Lists)

users = ["Tom", "Dick", "Harry"]

Enum.each(users, fn user ->
  IO.puts("Hello " <> user)
end)

Operador de encadeamento (Pipe Operator |>)

Envia o resultado da expressao a esquerda como primeiro argumento da funcao a direita:

source
|> transform(:hello)
|> print()

# Equivalente a:
print(transform(source, :hello))

Correspondência de padrões (Pattern Matching)

O operador = atua como operador de correspondencia de padroes estruturais:

user = %{name: "Tom", age: 23}
%{name: username} = user
# username is bound to "Tom"

# O operador pin (^) valida o valor sem reatribuir
x = 1
^x = 1  # Sucesso
# ^x = 2 # Erro MatchError

Correspondência de padrões nos cabeçalhos de função

defmodule UserGreeter do
  def greet(%{name: username}) do
    IO.puts("Hello, " <> username)
  end
end

Fluxo de controle (Control Flow)

`if` & `unless`

if status == :ok do
  "Ready"
else
  "Pending"
end

`case`

case {1, 2, 3} do
  {4, 5, 6} -> "No match"
  {1, x, 3} -> "Matches and binds x to 2"
  _ -> "Wildcard matches any value"
end

`cond`

Avalia condicoes sequencialmente ate encontrar a primeira verdadeira:

cond do
  1 + 1 == 3 -> "Never matches"
  2 * 5 == 12 -> "Neither"
  true -> "Matches (acts as else)"
end

`with`

Encadeia correspondencias com seguranca e para no primeiro erro:

with {:ok, {int, _}} <- Integer.parse("123abc"),
     {:ok, datetime, _offset} <- DateTime.from_iso8601("2026-10-25T12:00:00Z") do
  DateTime.add(datetime, int, :second)
else
  :error -> "Invalid integer format"
  {:error, :invalid_format} -> "Invalid ISO datetime"
  _ -> "Unhandled error"
end

Tipos e operadores (Types & Operators)

is_atom/1       is_boolean/1    is_binary/1
is_integer/1    is_float/1      is_number/1
is_list/1       is_map/1        is_tuple/1
is_nil/1        is_function/1   is_pid/1

Coleções e estruturas de dados (Collections & Data Structures)

Maps

m = %{name: "Alice", age: 30}

# Sintaxe para atualizar chave existente
m = %{m | age: 31}

# Funcoes do modulo Map
Map.get(m, :name)                # "Alice"
Map.put(m, :city, "Tokyo")       # Adds :city
Map.delete(m, :age)              # Removes :age
Map.merge(m, %{active: true})    # Merges maps

Lists & Enums

list = [1, 2, 3, 4]

# Prepend O(1) e append O(N)
[0 | list]    # [0, 1, 2, 3, 4]
list ++ [5]   # [1, 2, 3, 4, 5]

# Operacoes com Enum
Enum.map(list, &(&1 * 2))        # [2, 4, 6, 8]
Enum.filter(list, fn x -> rem(x, 2) == 0 end) # [2, 4]
Enum.reduce(list, 0, &+/2)       # 10

Funções (Functions)

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

# Sintaxe de captura
square = &(&1 * &1)
square.(5) # 25

# Captura de referencia a funcao
fun = &String.upcase/1
fun.("hello") # "HELLO"

Estruturas e protocolos (Structs & Protocols)

defmodule User do
  defstruct name: "", age: nil
end

user = %User{name: "Alice", age: 30}
user.name # "Alice"

defprotocol Blank do
  @doc "Returns true if data is empty"
  def blank?(data)
end

defimpl Blank, for: List do
  def blank?([]), do: true
  def blank?(_), do: false
end

Blank.blank?([]) # true

Compreensões (for)

for n <- 1..5, do: n * 2
# => [2, 4, 6, 8, 10]

for n <- 1..10, rem(n, 2) == 0, do: n
# => [2, 4, 6, 8, 10]

for {k, v} <- %{a: 1, b: 2}, into: %{}, do: {k, v * 10}
# => %{a: 10, b: 20}

Comportamentos e especificações de tipos (Behaviours & Type Specs)

defmodule Parser do
  @callback parse(String.t()) :: {:ok, any()} | {:error, String.t()}
  @callback extensions() :: [String.t()]
end

defmodule JSONParser do
  @behaviour Parser

  @impl Parser
  def parse(str), do: {:ok, str}

  @impl Parser
  def extensions, do: [".json"]
end