← Volver a los ejercicios

flatMap: por qué map deja el resultado anidado

map deja un resultado por cada elemento, tal como lo devolvió la función. Cuando esa función produce otra secuencia, el resultado es una secuencia de secuencias, y las parejas que se buscaban quedan repartidas en trozos. flatMap hace el mismo recorrido y concatena los trozos. Las dos expresiones de abajo se diferencian en esa palabra, y lo que imprime cada una salió de correr el código con la versión de Scala del proyecto del curso.

1. La misma expresión con map y con flatMap

1val anidado = (1 to 3).map(x => (1 to 2).map(y => (x, y)))
2val plano = (1 to 3).flatMap(x => (1 to 2).map(y => (x, y)))

El map interno es idéntico en las dos líneas: con un x fijo recorre (1 to 2) y arma una pareja por cada y. Las dos preguntas son sobre la primera línea.

2. ¿Cuántas parejas tiene plano?

Escoja el número antes de abrir la traza.

3. La traza, trozo por trozo

La expresión de la segunda línea, repartida en varias para poder señalar cuál se está evaluando. El contador de cada línea dice cuántas veces se evaluó.

paso 0 de 0
trozos reunidos–
lo que devuelve flatMap–
■ línea 2: el generador de afuera le da un valor a x ■ líneas 3 a 5: el map interno arma las parejas de ese x ■ línea 6: flatMap concatena los trozos

La caja de arriba reúne los trozos que ya entregó el map interno, uno por cada x. La de abajo queda en blanco hasta la línea 6, que es donde los trozos se concatenan: hasta ese momento no existe ninguna secuencia plana.

4. Componer zip, map y sum

1def esPrimo(n: Int): Boolean =
2 n >= 2 && (2 until n).forall(d => n % d != 0)
4def prodEscalar(xs: Vector[Double], ys: Vector[Double]): Double =
5 (xs zip ys).map { case (x, y) => x * y }.sum

La primera pregunta es sobre prodEscalar, donde tres operaciones se encadenan en una línea. Las otras dos son sobre las parejas (i, j) con 1 <= j < i < 7 cuya suma es prima, que se arman con flatMap y se escogen con filter.

5. Lo que se lleva de aquí

La traza muestra que flatMap no hace un recorrido distinto del de map. Las dos evalúan el map interno una vez por cada x y obtienen los mismos tres trozos, que juntos son exactamente lo que imprime la versión con map. La diferencia está en la última línea: map entrega los tres trozos tal como llegaron y flatMap los concatena. De ahí que el primero tenga largo 3 y el segundo 6.

Esa diferencia decide cuál de las dos se usa. Si la función devuelve un solo valor por elemento, map alcanza. Si devuelve una secuencia, map deja el trabajo a medias y hay que aplanar después; flatMap ahorra ese paso y es lo que permite que de dos generadores salga una sola lista de parejas. El orden del resultado lo fija el recorrido: el generador de adentro varía más rápido, así que las dos parejas de x = 1 salen antes que cualquiera de x = 2.

prodEscalar es la otra cara del mismo encadenamiento. Cada operación cambia la forma del dato: zip pasa de dos vectores de Double a uno de parejas, el map pasa de las parejas a los productos y sum pasa del vector al número 32.0. La definición entera cabe en una línea porque ninguna de las tres necesita saber en qué posición va: la posición la maneja zip.

En las parejas primas el filter va al final, sobre el vector plano, cuando cada pareja ya tiene sus dos componentes y la condición esPrimo(i + j) puede evaluarse. Con i = 4 el map interno arma (4,1), (4,2) y (4,3), y el resultado conserva (4,1) y (4,3).