Uno de mis problemas con la evaluación perezosa en Haskell es la dificultad de razonar sobre el uso de la memoria. Creo que la capacidad de duplicar un procesador me haría esto mucho más fácil. Aquí hay un ejemplo.

Vamos a crear una lista realmente grande:

let xs = [1..10000000]

Ahora, vamos a crear una mala función:

bad = do
    print $ foldl1' (+) xs
    print $ length xs

Sin optimizaciones, esto consume unas pocas docenas de MB de RAM. El recolector de basura no puede desasignar xs durante el pliegue porque será necesario para calcular la longitud más adelante.

¿Es posible volver a implementar esta función algo como esto:

good = do
    (xs1,xs2) <- copyThunk xs
    print $ foldl1' (+) xs1
    print $ length xs2

Ahora, xs1 y xs2 representarían el mismo valor, pero también serían independientes entre sí en la memoria, por lo que el recolector de basura puede desasignarse durante el pliegue, lo que evita el desperdicio de memoria. (Aunque creo que esto aumentaría ligeramente el costo computacional?)

Obviamente, en este ejemplo trivial, refactorizar el código podría resolver fácilmente este problema, pero parece que no siempre es obvio cómo refactorizar. O a veces la refactorización reduciría enormemente la claridad del código.