← Volver a los ejercicios

Tuplas: el valor, el tipo y lo que no compila

Una tupla agrupa valores de tipos distintos y su tamaño queda fijo al escribirla. No es recursiva, así que no se recorre con head y tail: a cada componente se llega por su posición, con _1 y _2, o repartiendo la tupla con un patrón. Abajo hay trece preguntas sobre estas dos tuplas. Lo que devuelve cada expresión, y lo que dice el compilador cuando algo no cuadra, salió de correr el código con la misma versión de Scala del proyecto del curso.

1. Las dos tuplas

La primera tiene dos componentes y la segunda tres. Los comentarios son lo que responde el intérprete al declararlas.

2. ¿Qué devuelve cada expresión?

Seis expresiones sobre esas dos tuplas. Elija el valor antes de seguir; cada opción equivocada dice en qué consiste la confusión.

3. ¿De qué tipo es?

El valor y el tipo se responden por separado, porque es justo ahí donde se confunde la tupla entera con uno de sus componentes.

4. Cuatro declaraciones: ¿cuáles compilan?

Las cuatro se escriben sobre pareja y triple. Después de responder aparece lo que contesta el compilador, copiado de la corrida.

5. Lo que se lleva de aquí

Una lista y una tupla resuelven cosas distintas. La lista pide un solo tipo para todos sus elementos y crece cuanto haga falta; la tupla admite un tipo por posición y su tamaño queda escrito en el tipo. Por eso (Double, String, Boolean) es un tipo legítimo y List no puede hacer lo mismo sin perder la información de qué hay en cada puesto.

El paréntesis es azúcar sintáctica. El tipo (String, Int) es Tuple2[String, Int] y la expresión ("hola", 42) es scala.Tuple2("hola", 42): las dos formas construyen el mismo valor, y de ahí sale que existan Tuple2 hasta Tuple22 y que _3 no exista en una pareja. Al ser una clase de las que comparan por contenido, dos tuplas escritas igual son iguales con ==.

Quedan dos formas de llegar a los componentes. Con _1 y _2 se saca uno a la vez y el nombre no dice nada de lo que contiene. Con val (texto, valor) = pareja se reparten los dos en una línea y cada uno queda con el nombre que corresponde, que es el mismo mecanismo que permite escribir case (x :: xs, y :: ys) para avanzar dos listas a la vez.