Calculadora de cocina

Tuplas

En Elixir, una tupla es una estructura de datos que organiza datos y que contiene un número fijo de elementos de cualquier tipo, pero sin nombres explícitos para cada elemento. Las tuplas se usan a menudo en Elixir para operaciones que hacen un uso intensivo de lectura de memoria, ya que acceder a un elemento es una operación de tiempo constante. Por lo general, no se usan cuando puede ser necesario agregar o quitar elementos de forma dinámica, porque en lugar de modificar la tupla existente se crea una tupla nueva, lo que requiere reservar memoria de antemano.

En la práctica, las tuplas se crean en Elixir con llaves. Se puede acceder a cada elemento de una tupla por separado con la función elem/2, usando índices que empiezan en 0:

empty_tuple = {}
one_element_tuple = {1}
multiple_element_tuple = {1, :a, "hello"}

elem(multiple_element_tuple, 2)
# => "hello"

Las tuplas como información agrupada

En la práctica, las tuplas se usan a menudo para representar información agrupada.

Float.ratio(0.25)
# => {1, 4} indicating the numerator and denominator of the fraction ¼

Coincidencia de patrones

El uso de la coincidencia de patrones predomina en el código Elixir idiomático y asertivo. Quizá recuerdes que =/2 se describe como un operador de coincidencia y no como un operador de asignación. Cuando usas el operador de coincidencia, si el patrón de la izquierda coincide con el de la derecha, las variables de la izquierda quedan enlazadas y se devuelve el valor del lado derecho. Si no hay coincidencia, se genera un MatchError.

2 = 2
# => 2
# Literals can be matched if they are the same

2 = 3
# => ** (MatchError) no match of right hand side value: 3

{_, denominator} = Float.ratio(0.25)
# => {1, 4}
# the variable `denominator` is bound to the value 4

Recuerda que las coincidencias se producen del lado derecho al lado izquierdo.

En el último ejemplo, si no necesitamos una variable en una coincidencia de patrones, podemos descartarla usando _. El entorno de ejecución no hace seguimiento de ninguna variable que empiece con _.

Coincidencia de patrones en funciones con nombre

La coincidencia de patrones también es una herramienta útil cuando se crean varias cláusulas de función. Se puede usar la coincidencia de patrones en los argumentos de las funciones, lo que determina qué cláusula de función se invoca, empezando por la parte superior del archivo y bajando hasta la primera coincidencia. Las variables se pueden enlazar en el encabezado de la función y usar en el cuerpo de la función.

defmodule Example do
  def named_function(:a = variable_a) do
    {variable_a, 1}
  end

  def named_function(:b = variable_b) do
    {variable_b, 2}
  end
end

Example.named_function(:a)
# => {:a, 1}

Example.named_function(:b)
# => {:b, 2}

Example.named_function(:c)
# => ** (FunctionClauseError) no function clause matching in Example.named_function/1