Aide-mémoire Langage de programmation Elixir

Elixir est un langage dynamique et fonctionnel concu pour creer des applications evolutives et tolerantes aux pannes sur la VM Erlang (BEAM).

🔗 Connexe : Aide-memoire Metaprogrammation Elixir · Aide-memoire Absinthe GraphQL · Aide-memoire Phoenix Framework

Démarrage rapide (Getting Started)

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

Greeter.greet("world")

Execution via la CLI Elixir :

elixir hello.exs
# => Hello, world!

---

Variables et immutabilité (Variables & Immutability)

age = 23
age = 24 # Re-liaison (ne mute pas la valeur d'origine)

---

Cartes (Maps)

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

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

---

Listes (Lists)

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

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

---

Opérateur de composition (Pipe Operator |>)

Prend le resultat de l'expression de gauche et le passe comme premier argument a la fonction de droite :

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

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

---

Filtrage par motif (Pattern Matching)

L'operateur = est en realite un operateur de correspondance structurelle de motifs :

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

# L'operateur pin (^) filtre sans re-lier la variable
x = 1
^x = 1  # Succes
# ^x = 2 # MatchError

Pattern Matching dans les têtes de fonctions

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

---

Structures de contrôle (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

Evalue les conditions sequentiellement jusqu'a la premiere valeur vraie :

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

with

Enchaine plusieurs correspondances et s'interrompt des la premiere erreur :

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

---

Types et opérateurs (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

---

Collections et structures de données (Collections & Data Structures)

Maps

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

# Syntaxe de mise a jour d'une cle existante
m = %{m | age: 31}

# Fonctions du module 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]

# Ajout en tete O(1) et en queue O(N)
[0 | list]    # [0, 1, 2, 3, 4]
list ++ [5]   # [1, 2, 3, 4, 5]

# Operations avec 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

---

Fonctions (Functions)

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

# Syntaxe de capture
square = &(&1 * &1)
square.(5) # 25

# Capture de reference de fonction
fun = &String.upcase/1
fun.("hello") # "HELLO"

---

Structures et protocoles (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

---

Compréhensions (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}

---

Comportements et spécifications de types (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