Cuando trabajamos con Elixir, es fundamental entender cómo manejar tipos compuestos que nos permitan agrupar múltiples valores en una sola estructura. Uno de los tipos compuestos más útiles que encontramos en Elixir son las tuplas. Estas estructuras nos permiten encapsular varias expresiones o variables en una única expresión inmutable, lo que facilita la organización y manipulación de datos relacionados.
Las tuplas se escriben entre llaves {} y dentro de ellas podemos incluir múltiples valores separados por comas. Lo interesante es que estos valores pueden ser de distintos tipos, por ejemplo, podemos tener un átomo, un número entero, una cadena de texto y un número flotante todos juntos en la misma tupla. Esto nos da mucha flexibilidad para representar datos complejos, como coordenadas en un espacio tridimensional o cualquier conjunto de valores relacionados.
Un uso muy común de las tuplas en Elixir es para devolver múltiples valores desde una función. En lugar de limitarse a devolver un solo valor, podemos devolver una tupla que contenga varios resultados. Por ejemplo, si queremos crear una función que calcule el cociente y el resto de una división entera, podemos devolver ambos valores agrupados en una tupla. Para hacer esto, podemos usar la función div para obtener el cociente y rem para obtener el resto, y luego devolverlos juntos.
Podemos definir esta función anónima de la siguiente manera:
div_y_resto = fn a, b -> {div(a, b), rem(a, b)} end
Si la llamamos con los valores 8 y 3, nos devolverá la tupla {2, 2}, donde 2 es el cociente y 2 es el resto.
Es importante destacar que en Elixir las tuplas son inmutables. Esto significa que no podemos modificar una tupla una vez creada, sino que cualquier operación que parezca modificarla en realidad devuelve una nueva tupla con los cambios aplicados. Por ejemplo, si queremos añadir un elemento a una tupla, podemos usar la función Tuple.append/2, que recibe la tupla original y el nuevo elemento, y devuelve una nueva tupla con ese elemento añadido al final.
tupla_original = {4, 0}
tupla_nueva = Tuple.append(tupla_original, 2)
# tupla_nueva es {4, 0, 2}
Pero la tupla original tupla_original sigue siendo {4, 0} porque no se modifica.
Para acceder a los elementos de una tupla, podemos usar la función elem/2, que recibe la tupla y el índice del elemento que queremos obtener. Los índices comienzan en 0, por lo que el primer elemento está en la posición 0, el segundo en la 1, y así sucesivamente.
Por ejemplo:
tupla = {4, 2, "hola", :adios}
elem(tupla, 0) # devuelve 4
elem(tupla, 1) # devuelve 2
elem(tupla, 2) # devuelve "hola"
elem(tupla, 3) # devuelve :adios
Si intentamos acceder a un índice que no existe, Elixir nos dará un error.
Este enfoque de usar tuplas para agrupar valores y devolver múltiples resultados es muy útil, especialmente cuando combinamos estas estructuras con funciones, ya que nos permite manejar datos complejos de forma clara y eficiente. Además, la inmutabilidad de las tuplas es una característica clave que facilita la programación concurrente y distribuida en Elixir, ya que garantiza que los datos no cambien inesperadamente cuando se comparten entre procesos.