← Volver a los ejercicios

Lo que un flujo perezoso no calcula

Un rango calcula sus elementos todos de una vez. Pedir ((1000 to 10000).filter(esPrimo))(1) prueba esPrimo en los números del rango de punta a punta y arma la secuencia entera de primos para entregar uno solo. Un LazyList cambia el momento del cálculo: con #:: la cabeza y la cola quedan descritas, y cada una se calcula cuando algo la pide. Las siete preguntas van del costo del rango a lo que aparece al imprimir un flujo que nadie ha consultado, y cada resultado salió de correr el código con la versión de Scala del curso.

1. Filtrar un rango entero para quedarse con uno

2. El flujo recién construido

11 #:: 2 #:: LazyList.empty

Dos elementos y el final, escritos a mano con #::. La pregunta es qué contesta el intérprete.

3. El mismo filtro sobre un flujo

streamRange entrega su primer número y deja la llamada recursiva a la derecha de #::, sin evaluar. El filtro es el mismo esPrimo del rango.

4. Qué se calcula y cuándo

1#:: describe la cabeza y la cola sin evaluar ninguna de las dos. Por eso 1 #:: 2 #:: LazyList.empty imprime LazyList(<not computed>): no hay un elemento calculado del que informar.
2Pedir un elemento es lo que lo calcula. .toList pide todos, y sobre ese flujo devuelve List(1, 2).
3Un índice obliga a calcular los elementos anteriores, no al que se pide: primos(4) devuelve 1031 tras encontrar los cuatro primos que lo preceden, y del 1032 en adelante nada se calcula.
4El filtro de un flujo pide elementos mientras le falten; el de un rango recorre todo antes de devolver.
ExpresiónResultado
1 #:: 2 #:: LazyList.empty LazyList(<not computed>)
(1 #:: 2 #:: LazyList.empty).toList List(1, 2)
primos(0) 1009
primos(1) 1013
primos(4) 1031

Las dos primeras filas son el mismo flujo antes y después de que algo le pida sus elementos. La impresión de un flujo informa de lo que ya está calculado, y recién construido eso es nada: ni la cabeza, que es la parte que se suele dar por hecha.

Las tres últimas filas salen del mismo val primos. El filtro no recorre el flujo al escribirse: queda encima de él, y cada índice que se pide lo hace avanzar justo hasta encontrar el primo que falta. Con filter sobre 1000 to 10000 el reparto es otro: la secuencia de primos se arma completa y el índice la consulta después.

Las dos formas devuelven 1013 en el índice 1, así que la diferencia no está en el resultado sino en el trabajo. También difieren en el extremo del rango: streamRange para cuando min >= max y produce hasta 9999, mientras 1000 to 10000 incluye el 10000.