Comment fonctionne l'évaluation paresseuse?

Question

Je suis nouveau à la programmation fonctionnelle et je veux savoir pourquoi l'évaluation paresseuse fonctionne. Je les fonctions suivantes:

nats = 0:(map (+1) nats) 
test = foldr (\x y-> if x > 2 then 0 else x+y) 10 nats 

Et pour autant que je peux dire, le premier obtient la liste de tous les nombres naturels jusqu'à ce qu'il est à court de mémoire (mais qui ne se passe vraiment, que je comprends), et le second est censé faire exactement quoi? Test a une fonction de calcul lambda qui obtient un x et y et renvoie 2 si x> 2 et x + y sinon, mais est-ce supposé vouloir dire qu'il retournera 0 parce que x = 10? Je suis un peu confus. Dans ce cas, les nats sont-ils vraiment appelés?

EDIT: Test renvoie 3, mais maintenant je suis vraiment confus parce que je ne comprends pas comment.

Merci et désolé si je fais une erreur de débutant, mais je ne parviens pas à comprendre comment cela fonctionne.

Answer 1

ces réductions vous aider peut-être:

let x `op` y = if x > 2 then 0 else x + y 

test          => 
foldr op 10 [0..]       => 
0 `op` foldr op 10 [1..]     => 
0 + foldr op 10 [1..]      => 
0 + (1 `op` foldr op 10 [2..])    => 
0 + (1 + foldr op 10 [2..])    => 
0 + (1 + (2 `op` foldr op 10 [3..]))  => 
0 + (1 + (2 + foldr op 10 [3..]))   => 
0 + (1 + (2 + (3 `op` foldr op 10 [4..]))) => 
0 + (1 + (2 + 0))       => 
0 + (1 + 2)        => 
0 + 3          => 
3