Enum en

À propos de Enum

Enum est un module très utile qui fournit un ensemble d'algorithmes pour manipuler des énumérables. Il propose :

• le tri (sort/2, sort_by/2),
• le filtrage (filter/2),
• le regroupement (group_by/3),
• le comptage (count/2)
• la recherche (find/3),
• trouver les valeurs min/max (min/3, max/3),
• la réduction (reduce/3, reduce_while/3),

Et bien plus encore ! Consulte la documentation du module Enum pour une liste complète.

Énumérable

De manière générale, un énumérable est une donnée que l'on peut parcourir, une collection. En Elixir, un énumérable est n'importe quel type de données qui implémente le protocole Enumerable. Ce sont :

• List
• Map
• Range
• Stream
• MapSet
• Function
• Date.Range
• IO.Stream
• File.Stream

Pas de panique si tu ne les connais pas encore tous.

Chacun peut implémenter le protocole Enumerable pour sa propre structure de données personnalisée.

Réduis

Enum.reduce/2 te permet de réduire tout l'énumérable à une seule valeur. Pour y parvenir, on utilise une variable spéciale appelée l'accumulateur. L'accumulateur transporte l'état intermédiaire de la réduction d'une itération à l'autre. Ce qui en fait l'une des fonctions les plus puissantes pour travailler avec les énumérables. De nombreuses autres fonctions spécialisées pourraient être remplacées par la fonction plus générale reduce. Par exemple...

Trouver la valeur maximale :

Enum.max([4, 20, 31, 9, 2])
# => 31

Enum.reduce([4, 20, 31, 9, 2], nil, fn x, acc ->
  cond do
    acc == nil -> x
    x > acc -> x
    x <= acc -> acc
  end
end)

# => 31

Et même le map (mais il faut ensuite inverser le résultat) :

Enum.map([1, 2, 3, 4, 5], fn x -> x + 10 end)
# => [11, 12, 13, 14, 15]

Enum.reduce([1, 2, 3, 4, 5], [], fn x, acc -> [x + 10 | acc] end)
# => [15, 14, 13, 12, 11]

Mappe des maps

• Avec Map.new/2 :

  %{a: 1, b: 2}
  |> Map.new(fn {key, value} -> {key, value * 10} end)
  

• Avec Enum.into/3 :

  %{a: 1, b: 2}
  |> Enum.into(%{}, fn {key, value} -> {key, value * 10} end)
  

• Avec Enum.map/2 :

  %{a: 1, b: 2}
  |> Enum.map(fn {key, value} -> {key, value * 10} end)
  |> Enum.into(%{})