Una expresión for no se ejecuta como está
escrita: el compilador la reescribe con funciones de alto orden y lo que
corre es esa cadena. La reescritura se puede seguir pieza por pieza, y cada
pieza que se agrega a la expresión agrega una función a la cadena: el
generador y el yield traen el map, el
if trae el withFilter y un segundo generador trae
el flatMap. Las nueve preguntas van de lo simple a lo compuesto,
y cada resultado salió de correr la expresión y su cadena con la versión de
Scala del curso.
El generador sigue trayendo el map. La
pregunta es qué función trae el if y qué cambia según cuál de
las dos se escriba.
Dos generadores y un if, con el segundo
generador dependiente del primero. La cadena tiene las tres funciones, y
las tres preguntas son dónde queda cada una.
yield: la colección del generador recibe la
llamada y el cuerpo del yield es la función que entra al
map.if: entra un withFilter delante del
map, con la condición tal como está escrita.flatMap y todo lo que
viene después queda dentro de su función, filtro incluido.yield: no hay map que construya nada, y la
expresión vale ().| La expresión for | La cadena que corre |
|---|---|
for (x <- Vector(1, 2, 3)) yield x * 2 |
Vector(1, 2, 3).map(x => x * 2) |
for (x <- Vector(1, 2, 3, 4) if x % 2 == 0) yield x * x |
Vector(1, 2, 3, 4).withFilter(x => x % 2 == 0).map(x => x * x) |
for { i <- 2 until 7; j <- 1 until i; if esPrimo(i + j) } yield (i, j) |
(2 until 7).flatMap(i => (1 until i).withFilter(j => esPrimo(i + j)).map(j => (i, j))) |
Las tres filas se corrieron por los dos lados y los dos lados coinciden:
Vector(2, 4, 6), Vector(4, 16) y
Vector((2,1), (3,2), (4,1), (4,3), (5,2), (6,1), (6,5)).
El withFilter de la segunda fila se puede cambiar por
filter y el resultado sigue siendo Vector(4, 16).
La diferencia está en el camino: filter arma una colección con
los elementos que pasaron y el map recorre esa colección,
mientras withFilter no la arma y deja que el
map aplique la condición al pasar. Con cuatro elementos eso no
se mide; con una colección grande es una colección entera que no se
construye.
En la tercera fila está lo que decide la forma del resultado. El filtro
queda dentro de la función del flatMap, sobre j,
porque ahí la condición puede nombrar i y j. El
map interno arma la pareja y entrega un trozo por cada
i: Vector((2,1)) con i = 2,
Vector((4,1), (4,3)) con i = 4,
Vector((5,2)) con i = 5. El
flatMap los concatena. Con map en ese lugar se
quedan separados, y lo corrido devuelve cinco vectores:
Vector(Vector((2,1)), Vector((3,2)), Vector((4,1), (4,3)), Vector((5,2)), Vector((6,1), (6,5))).
El yield es lo que hace de la expresión un valor. Sin él no
hay map en la cadena ni colección que devolver:
for (x <- Vector(1, 2, 3)) println(x) imprime 1, luego 2,
luego 3, y vale (), de tipo Unit. Con él, la
expresión vale una colección, se le puede poner nombre con un
val y se sigue usando.