En Elixir contamos con tres operadores lógicos fundamentales que implementan la lógica proposicional binaria: Not, And y Or. Estos operadores trabajan evaluando expresiones a True o False según el valor de verdad de sus operandos. Aunque en realidad existen seis operadores, se dividen en dos variantes: una estricta y otra relajada. Para entender bien su funcionamiento, es útil comenzar por la variante estricta.
El operador Not es un operador unario que niega el valor booleano de la expresión que tiene a su derecha. Por ejemplo, Not False evalúa a True y Not True evalúa a False. No importa si el valor es una constante o una variable, lo que importa es el resultado booleano de la expresión que se evalúa a la derecha.
El operador And es binario y devuelve True únicamente cuando ambos operandos, el de la izquierda y el de la derecha, son True. Si alguno de los dos es False, el resultado será False. Por ejemplo, True and True es True, pero True and False o False and True son False.
Por otro lado, el operador Or devuelve True si al menos uno de sus operandos es True. Solo devuelve False cuando ambos son False. Así, True or False y False or True son True, mientras que False or False es False.
Estos operadores pueden combinarse para formar expresiones más complejas. La evaluación sigue un orden de precedencia: primero se evalúan los Not, luego los And y finalmente los Or. Por ejemplo, en la expresión Not False and True, primero se evalúa Not False que es True, y luego True and True que también es True. En cambio, True and Not True es False porque Not True es False y True and False es False. También podemos combinar varios operadores del mismo tipo, evaluándose de izquierda a derecha.
Sin embargo, esta variante estricta tiene limitaciones cuando los operandos no son valores booleanos. Por ejemplo, Not 5 o 5 and 3 generan errores porque estos operadores esperan expresiones que se evalúen a True o False.
Para manejar estos casos, Elixir ofrece una variante relajada de los operadores lógicos: el operador ! para Not, && para And y || para Or. Estos operadores aceptan valores que no son estrictamente booleanos y aplican una lógica diferente: consideran que cualquier valor que no sea false ni nil es true. Por ejemplo, !nil es true y !5 es false porque 5 se interpreta como true y su negación es false.
En esta variante relajada, el operador && devuelve el primer valor que sea falso o nil si lo encuentra a la izquierda, evitando evaluar el operando derecho (cortocircuito). Si el valor de la izquierda es verdadero (es decir, distinto de false o nil), entonces devuelve el valor de la derecha. Por ejemplo, 5 && true devuelve true, mientras que nil && true devuelve nil.
El operador || funciona de manera similar pero con la lógica inversa: devuelve el primer valor verdadero que encuentre, o el último valor si todos son falsos o nil. Esto es útil para establecer valores por defecto. Por ejemplo, si tenemos una variable que puede ser nil, podemos usar variable || "valor por defecto" para asegurarnos de que siempre haya un valor válido.
Esta característica es especialmente práctica para evitar errores cuando trabajamos con valores que pueden ser nil. Por ejemplo, si queremos enviar algo a una dirección que podría no estar definida, podemos usar direccion || "sin dirección" para garantizar que siempre haya un valor válido.
Con estas seis variantes de operadores lógicos, podemos construir expresiones booleanas robustas que manejan tanto valores estrictamente booleanos como valores más generales, facilitando la escritura de código seguro y expresivo en Elixir.