Una expresión for con yield no
recorre por recorrer: construye una colección nueva con el valor del
yield y la devuelve, de modo que se le puede asignar a un
val. Cada pieza de la expresión corresponde a una función de
alto orden: el generador y el yield a map, el
if a filter, y un segundo generador a
flatMap. Las diez preguntas trabajan sobre las cuatro
expresiones del código del tema, y lo que devuelve cada una salió de
correrlo con la versión de Scala del proyecto del curso.
Las dos últimas preguntas usan estas definiciones: la de
primalidad para el filtro de las parejas y el case class para
el vector de personas.
Cinco cadenas de funciones de alto
orden y cuatro expresiones for. A cada expresión le
corresponde una, y una de las cinco no le corresponde a ninguna. Elija la
letra; cada letra equivocada dice qué hace esa cadena y qué pide la
expresión.
| En la expresión for | Se traduce a |
|---|---|
un generador y el yield | map |
un if | filter |
| un generador más, dentro del primero | flatMap, con el map adentro |
La tabla se lee en los dos sentidos. Una cadena de
flatMap con un map dentro y un filter
encima se puede reescribir como un for de dos generadores y un
if, y el resultado es el mismo vector.
El for de Scala no es el ciclo de un
lenguaje imperativo. No hay una variable de control que avance ni un
contador que se modifique: hay un generador que recorre una colección y un
yield cuyo valor entra en otra colección. Como la expresión
completa vale esa colección, se escribe
val dobles = for (x <- Vector(1, 2, 3)) yield x * 2 y se
sigue usando dobles, que es Vector(2, 4, 6). La
colección de partida no cambia.
El orden de la traducción importa y la expresión lo deja ver. Con un
generador y un if, el filter va antes del
map: se descarta primero y se transforma lo que quedó. Si
fuera al contrario, la condición decidiría sobre valores que el
yield ya cambió, y en
for (p <- personas if p.edad > 20) yield p.nombre eso ni
siquiera se podría escribir, porque el nombre no trae la edad.
Con dos generadores aparece el flatMap, y la razón es la
forma del resultado. El generador de adentro produce una secuencia por cada
valor del de afuera, de modo que un map dejaría una secuencia
de secuencias. Es lo que hace la cadena E, que no le corresponde a ninguna
de las cuatro expresiones. El flatMap concatena esos trozos y
entrega la secuencia plana de parejas que el for escribe en
tres líneas.
Las dos escrituras de las parejas primas se corrieron por separado y las
dos devuelven
Vector((2,1), (3,2), (4,1), (4,3), (5,2), (6,1), (6,5)). La
diferencia es de lectura: con una sola operación la cadena de funciones es
más corta, y en cuanto hay dos generadores y un filtro, el
for nombra i y j en vez de llegar a
ellos por par._1 y par._2.