Elixir Language
Condicionales

Observaciones

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"

caso

 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 solo se utiliza para coincidir con el patrón dado de los datos particulares. Aquí, {1,2} se corresponde con un patrón de caso diferente que se da en el ejemplo de código.

si ya menos que

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 generará un CondClauseError si no se cumplen las condiciones.

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

Esto se puede evitar agregando una condición que siempre será verdadera.

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

A menos que nunca se espere que llegue al caso predeterminado, y el programa debería fallar en ese punto.

con cláusula

with cláusula se utiliza para combinar cláusulas coincidentes. Parece que combinamos funciones anónimas o manejamos funciones con varios cuerpos (cláusulas coincidentes). Considere el caso: creamos un usuario, lo insertamos en la base de datos, luego creamos un correo electrónico de bienvenida y luego lo enviamos al usuario.

Sin la cláusula with podríamos escribir algo como esto (omití implementaciones de funciones):

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

Aquí manejamos el flujo de nuestro proceso de negocio con el case (podría ser cond o if ). Eso nos lleva a la llamada 'pirámide de la fatalidad' , porque tenemos que lidiar con las posibles condiciones y decidir: seguir avanzando o no. Sería mucho mejor reescribir este código con with declaración:

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

En el fragmento de código anterior, hemos reescrito las cláusulas de case anidados with . Dentro de with invocamos algunas funciones (ya sea anónimas o con nombre) y la coincidencia de patrones en sus salidas. Si todo coincidentes, with retorno de do resultado del bloque, o de else resultado del bloque de otra manera.

Podemos omitir else manera with devolverá o bien do resultado del bloque o el resultado primero fallar.

Por lo tanto, el valor de with sentencia es su resultado de bloque do .