map y filter: prediga las dos listas de salidaLas dos funciones reciben otra función y recorren la lista
una vez. map aplica la que recibe a cada elemento;
filter le pregunta a un predicado cuáles conserva. Abajo hay
cuatro listas y, para cada una, las dos llamadas sobre la misma entrada.
Escriba lo que devuelve cada una antes de ver la ejecución.
La ejecución corre primero la pasada de map y
después la de filter sobre la misma lista. Los contadores de la
derecha dicen cuántas veces se evaluó cada línea; en la pasada de
filter los elementos quedan marcados en verde si pasaron y en
rojo si la rama else los descartó. Los botones y los cuatro
atajos quedan disponibles cuando las predicciones estén resueltas.
Escriba las listas con la forma
List(2, 4, 6). Para la lista sin elementos sirve
List() o Nil.
Los dos cuerpos se diferencian en una sola
decisión. El caso x :: xs de map construye
siempre f(x) :: xs.map(f): pone un elemento por cada elemento
que recibe, y el contador de esa línea termina igual a la longitud de la
entrada. El de filter tiene dos ramas, y solo la primera pone
algo al frente: cuando p(x) responde false, el
cuerpo devuelve xs.filter(p) y la x no vuelve a
aparecer. Los contadores de las líneas 9 y 10 reparten los elementos de la
entrada entre los que pasaron y los que no, y su suma es la longitud de la
lista original.
De ahí sale la otra diferencia. map no conserva los
elementos, los reemplaza por lo que devuelve f, y puede cambiar
el tipo de la lista: List(1, 2, 3, 4).map(x => x % 2 == 0)
devuelve List[Boolean] con cuatro valores.
filter usa el predicado para decidir y entrega los elementos
tal como entraron, así que el tipo de la lista nunca cambia y la longitud
casi nunca se conserva.
Con la lista sin elementos ninguna de las dos evalúa la función que
recibió. Las dos entran por case Nil => Nil, que es el único
caso que coincide, y devuelven Nil. Esa línea también es la que
cierra las otras tres ejecuciones: la recursión avanza sobre
xs hasta que la lista se acaba.