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.
La primera tiene dos componentes y la segunda tres. Los comentarios son lo que responde el intérprete al declararlas.
Seis expresiones sobre esas dos tuplas. Elija el valor antes de seguir; cada opción equivocada dice en qué consiste la confusión.
El valor y el tipo se responden por separado, porque es justo ahí donde se confunde la tupla entera con uno de sus componentes.
Las cuatro se escriben sobre
pareja y triple. Después de responder aparece lo
que contesta el compilador, copiado de la corrida.
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.