Elixir Language
Condizionali

Osservazioni

unless false, do: IO.puts("Condition is false")
# Outputs "Condition is false"

# With an `else`:
if false, do: IO.puts("Condition is true"), else: IO.puts("Condition is false")
# Outputs "Condition is false"

Astuccio

 case {1, 2} do
  {3, 4} ->
    "This clause won't match."
  {1, x} ->
    "This clause will match and bind x to 2 in this clause."
  _ ->
    "This clause would match any value."
end

case è usato solo per abbinare il modello dato dei dati particolari. Qui, {1,2} corrisponde a un diverso modello di caso che viene fornito nell'esempio di codice.

se e a meno

if true do
    "Will be seen since condition is true."
end    

if false do
    "Won't be seen since condition is false."
else
    "Will be seen.
end

unless false do
    "Will be seen."
end

unless true do 
    "Won't be seen."
else
    "Will be seen."
end

cond

cond do 
   0 == 1 -> IO.puts "0 = 1"
   2 == 1 + 1 -> IO.puts "1 + 1 = 2" 
   3 == 1 + 2 -> IO.puts "1 + 2 = 3" 
end

# Outputs "1 + 1 = 2" (first condition evaluating to true)

cond CondClauseError un CondClauseError se nessuna condizione è vera.

cond do
  1 == 2 -> "Hmmm"
  "foo" == "bar" -> "What?"
end
# Error

Questo può essere evitato aggiungendo una condizione che sarà sempre vera.

cond do
  ... other conditions
  true -> "Default value"
end

A meno che non sia previsto il raggiungimento del caso predefinito, e il programma dovrebbe in effetti bloccarsi in quel punto.

con clausola

with clausola viene utilizzata per combinare le clausole di corrispondenza. Sembra che combiniamo funzioni anonime o gestiamo funzioni con più corpi (clausole di corrispondenza). Considera il caso: creiamo un utente, lo inseriamo nel DB, quindi creiamo e-mail di saluto e quindi lo inviamo all'utente.

Senza la clausola with potremmo scrivere qualcosa di simile (ho omesso le implementazioni di funzioni):

case create_user(user_params) do
  {:ok, user} ->
    case Mailer.compose_email(user) do
      {:ok, email} ->
        Mailer.send_email(email)
      {:error, reason} ->
        handle_error
    end
  {:error, changeset} ->
    handle_error
end

Qui gestiamo il flusso del processo aziendale con il case (potrebbe essere cond o if ). Questo ci porta alla cosiddetta "piramide del destino" , perché dobbiamo affrontare le possibili condizioni e decidere: se avanzare o meno. Sarebbe molto più bello riscrivere questo codice with istruzione:

with {:ok, user} <- create_user(user_params),
     {:ok, email} <- Mailer.compose_email(user) do
  {:ok, Mailer.send_email}
else
  {:error, _reason} ->
    handle_error
end

Nello snippet di codice sopra abbiamo riscritto le clausole dei case annidate con with . Entro with invochiamo alcune funzioni (sia in forma anonima o nome) e pattern matching sulle loro uscite. Se tutto abbinato, with ritorno do risultato del blocco, o else risultato del blocco in caso contrario.

Siamo in grado di omettere else modo with restituirà o do risultato del blocco o il risultato prima fallire.

Così, il valore di with dichiarazione è il suo do risultato del blocco.