Cuatro libros con sus autores alcanzan para hacer las
preguntas que se le hacen a una base de datos: qué títulos cumplen algo, qué
escribió una persona, quién aparece en más de un sitio. Las cuatro consultas
se escriben con el mismo molde, un generador que recorre, un
if que decide y un yield que dice qué se guarda, y
de una a la siguiente cambia una sola línea. La última rompe el patrón: pide
dos generadores sobre la misma lista y devuelve un resultado con una copia de
más, que además se imprime de una forma que engaña. Cada opción equivocada
dice en qué consiste la confusión, y todo valor que la página da por correcto
salió de correr el código con Scala 2.13.11.
Cuatro libros. Uno tiene dos autores, uno tiene tres y dos
tienen uno solo. Cada autor se escribe como una sola cadena, con el
apellido primero y una coma antes del nombre, y eso tiene consecuencias más
abajo. Odersky, Martin es la única cadena de autor que se
repite entre dos libros.
Las dos consultas tienen la misma forma y devuelven títulos. Lo que cambia entre ellas está en una sola parte de la expresión.
Los autores de un libro son una lista, de modo que la condición no se puede escribir sobre el libro: hay que llegar a cada autor.
La consulta busca los autores que aparecen en al menos dos
libros: toma dos libros distintos, un autor de cada uno, y guarda el autor
cuando los dos coinciden. Lo que imprimió fue
List(Odersky, Martin, Odersky, Martin), y la primera pregunta
es cuántos elementos trae eso.
Dos maneras de quedarse con un solo nombre: pedirle a la lista que descarte sus repetidos, o recorrer un conjunto en lugar de una lista.
if dice qué pasa y el
yield dice qué se guarda de cada elemento que pasó.| La consulta | Lo que devolvió |
|---|---|
for (l <- libros if l.titulo.contains("Program")) yield l.titulo |
List(Structure and Interpretation of Computer Programs, Programming in Scala, Learning Concurrent Programming in Scala) |
for (l <- libros if l.autores.length == 1) yield l.titulo |
List(Learning Concurrent Programming in Scala, Working Hard to Keep it Simple) |
for { l <- libros; a <- l.autores if a.startsWith("Odersky,") } yield l.titulo |
List(Programming in Scala, Working Hard to Keep it Simple) |
for { l1 <- libros; l2 <- libros if l1 != l2; a1 <- l1.autores; a2 <- l2.autores if a1 == a2 } yield a1 |
List(Odersky, Martin, Odersky, Martin) |
Las tres primeras consultas se diferencian en poco: la segunda es la
primera con otra condición, y la tercera agrega el generador que hacía falta
para preguntar por un autor. La coma de
startsWith("Odersky,") está puesta a propósito: cierra el
apellido, de modo que la condición compara el apellido completo.
La última salida es la que hay que leer con cuidado.
List(Odersky, Martin, Odersky, Martin) muestra cuatro trozos
separados por coma y tiene dos elementos, porque cada autor se escribe
apellido, nombre y lleva una coma adentro, la misma con que la lista separa
sus elementos. Los dos elementos son la cadena
Odersky, Martin.
La copia sale del recorrido, no de los datos. Los dos generadores
recorren libros completo, de modo que el par formado por
Programming in Scala y Working Hard to Keep it Simple
aparece dos veces, una con cada libro en el papel de l1, y las
dos veces la condición a1 == a2 se cumple. La guarda
l1 != l2 evita comparar un libro consigo mismo y nada más.
De ahí las dos salidas que quitan la copia.
.distinct al final devuelve
List(Odersky, Martin): descarta sobre lo que ya se construyó.
Los mismos dos generadores sobre libros.toSet devuelven
Set(Odersky, Martin): el tipo del resultado lo fija el primer
generador, y un conjunto no deja entrar la copia. El recorrido es el mismo
en los tres casos y lo que cambia es dónde se descarta.