← Volver a los ejercicios

Del for a la cadena, una reescritura por vez

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.

1. Un generador y un yield

1val dobles = for (x <- Vector(1, 2, 3)) yield x * 2

2. Se agrega un if

1val cuadrPares = for (x <- Vector(1, 2, 3, 4) if x % 2 == 0) yield x * x

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.

3. Se agrega un segundo generador

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.

4. Un for sin yield

1for (x <- Vector(1, 2, 3)) println(x)

5. La derivación completa

1Un generador y el yield: la colección del generador recibe la llamada y el cuerpo del yield es la función que entra al map.
2Un if: entra un withFilter delante del map, con la condición tal como está escrita.
3Un segundo generador: el de afuera pasa a flatMap y todo lo que viene después queda dentro de su función, filtro incluido.
4Sin yield: no hay map que construya nada, y la expresión vale ().
La expresión forLa 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.