Haskell 惰性评估是如何工作的？

我是函数式编程的新手，我想了解惰性评估是如何工作的。我有以下职能：

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

据我所知，第一个得到的是所有自然数的列表，直到它的内存耗尽（但我知道这从来没有发生过），第二个应该做什么？Test内部有一个lambda演算函数，该函数得到一个x和y，如果x>2，则返回2，否则返回x+y，但这是否意味着它将返回0，因为x=10？我有点困惑。那样的话，nats真的需要吗

编辑： 测试返回3，但现在我真的很困惑，因为我不明白怎么做

---

如果我犯了一些新手错误，请向我表示感谢和歉意，但我无法理解这是如何工作的。

也许这些减少对您有帮助：

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

---

也许这些减少对你有帮助：

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

---

您只需将其向后放置：

x

范围覆盖使用的

nats

元素，并且

10

仅在满足

nats

结尾时使用，这意味着永远不会使用

10

。

foldr

计算

0+（1+（2+（0））

最后一个0是由于

x=3>2

使

if

返回0。您只需将其向后设置：

x

在

nats

的元素范围内，使用该元素，并且只有在

nats

结束时才会使用

10

，这意味着将永远不会使用

10

计算

0+（1+（2+（0））

其中最后一个0是由于

x=3>2

使

if

返回0。