Un Set no guarda un orden y no admite elementos
repetidos. Las operaciones que ya se usan sobre un Vector
(map, filter, exists) siguen
funcionando, y además aparecen union, intersect,
diff, contains y subsetOf. Las quince
preguntas de abajo trabajan sobre las cuatro declaraciones del archivo de la
sesión. Cada valor correcto y cada línea impresa salieron de correr ese
archivo con la versión de Scala del proyecto del curso.
El comentario es lo que println(frutas) saca
por pantalla. Qué saca println(nums) es una de las preguntas
de la última tarjeta.
Siete expresiones sobre
frutas, nums, a y b.
Elija el valor antes de seguir; cada opción equivocada dice en qué consiste
la confusión.
Las dos preguntas aplican
map a los seis elementos de nums, con dos
funciones distintas, y preguntan por el tamaño del resultado.
Las seis divisiones enteras, en el orden del rango:
El 1 sale de 2/2 y de 3/2; el 2, de 4/2 y de 5/2. Un conjunto guarda cada valor una sola vez, así que de seis resultados quedan cuatro elementos.
Aquí no se pregunta por los elementos sino por el texto que sale por pantalla, carácter por carácter. Las seis respuestas correctas son la salida literal de la corrida.
Un conjunto responde tres preguntas y no más: si un
valor pertenece (contains, o el conjunto aplicado al valor),
cuántos elementos distintos tiene (size) y cómo se combina con
otro conjunto (union, intersect,
diff, subsetOf). Fuera de eso están
map, filter, exists y
forall, que vienen de las secuencias y aquí también
funcionan.
Lo que no responde es en qué posición está cada elemento. No hay
primero ni último, a(3) no es un índice sino una pregunta de
pertenencia, y el orden en que los elementos salen por pantalla no es el
orden en que entraron: (1 to 6).toSet imprime
HashSet(5, 1, 6, 2, 3, 4). El nombre tampoco es estable.
(1 to 4).toSet sale como Set(1, 2, 3, 4) y
(1 to 6).toSet.map(_ / 2), que también tiene cuatro
elementos, sale como HashSet(0, 1, 2, 3). Un programa que
dependa de ese nombre o de ese orden dependería de algo que el conjunto no
promete.
El colapso de duplicados es lo que hace que map pueda
devolver menos elementos de los que recibió. Sobre un Vector,
map devuelve siempre tantos elementos como había; sobre un
conjunto, tantos como valores distintos produzca la función. Esa
es la diferencia entre nums.map(_ + 2).size, que da 6, y
nums.map(_ / 2).size, que da 4. Y es la razón de que
Vector(1, 2, 2, 3).toSet.size dé 3: pasar a conjunto es la
forma corta de quedarse con los valores distintos.