Enum in

Informazioni su Enum

Enum è un modulo molto utile che fornisce una serie di algoritmi per lavorare con gli enumerable. Offre:

• ordinamento (sort/2, sort_by/2),
• filtraggio (filter/2),
• raggruppamento (group_by/3),
• conteggio (count/2)
• ricerca (find/3),
• ricerca dei valori minimo e massimo (min/3, max/3),
• riduzione (reduce/3, reduce_while/3),

E molto altro ancora! Per un elenco completo, fai riferimento alla documentazione del modulo Enum.

Enumerable

In generale, un enumerable è un qualsiasi dato su cui si può iterare, cioè una collezione. In Elixir, un enumerable è un qualsiasi tipo di dato che implementa il protocollo Enumerable protocol. Questi sono:

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

Non preoccuparti se non li conosci ancora tutti.

Chiunque può implementare il protocollo Enumerable per una propria struttura dati personalizzata.

Reduce

Enum.reduce/2 ti permette di ridurre l'intero enumerable a un unico valore. Per farlo, si usa una variabile speciale chiamata accumulatore. L'accumulatore porta con sé lo stato intermedio della riduzione tra un'iterazione e l'altra. Questo lo rende una delle funzioni più potenti per gli enumerable. Molte altre funzioni specializzate potrebbero essere sostituite dal più generale reduce. Per esempio...

Trovare il valore massimo:

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

E persino la mappatura (ma richiede di invertire il risultato in seguito):

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]

Trasformare le mappe

• Con Map.new/2:

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

• Con Enum.into/3:

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

• Con Enum.map/2:

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