什么'；Haskell中计算递归数据的真实过程是什么？

我试图理解递归数据，但我有点困惑。我试过这个：

m = 1 : map (+1) m

这产生了一个与

[1..]

相同的列表。我试着像这样完成评估过程：

m = 1 : map (+1) m
  = 1 : map (+1) (1 : map (+1) m)
  = 1 : 2 : map (+1) (map (+1) m)
  = 1 : 2 : map (+1) (map (+1) (1 : 2 : map (+1) (map (+1) m)) )
  = 1 : 2 : map (+1) (2 : map (+1) (2 : (map (+1) (map (+1) m)) )
  = 1 : 2 : 3 : map (+1) (map (+1) (2 : (map (+1) (map (+1) m)))
  = 1 : 2 : 3 : map (+1) (3 : map (+1) ( (map (+1) (map (+1) m))) )
  = 1 : 2 : 3 : 4 : map (+1) (map (+1) ( (map (+1) (map (+1) m)) ))
  = ...

---

有很多

map（+1）

的东西在后面，并且随着过程的进行而增加。是否真的有这么多的

map（+1）

和重复计算

map（+1）…

？我读过其他提到thunks的帖子，但如何将它们联系起来呢？非常感谢。

接下来会发生的事情更像是

m = 1 : map (+1) m
    1 : map (+1) (1 : _)
        ^------------<|     Points to the same thunk in memory
    1 : a : map (+1) (a : _) where a = ((+1) 1)
            ^------------<|
    1 : 2 : map (+1) (2 : _)
            ^------------<|
    1 : 2 : a : map (+1) (a : _) where a = ((+1) 2)
                ^------------<|
    1 : 2 : 3 : map (+1) (3 : _)
                ^------------<|
    1 : 2 : 3 : a : map (+1) (a : _) where a = ((+1) 3)
                    ^------------<|
    1 : 2 : 3 : 4 : map (+1) (4 : _)
                    ^------------<|

m=1:map（+1）m
1：地图（+1）（1:
^------------ 接下来会发生的情况更像是这样

m = 1 : map (+1) m
    1 : map (+1) (1 : _)
        ^------------<|     Points to the same thunk in memory
    1 : a : map (+1) (a : _) where a = ((+1) 1)
            ^------------<|
    1 : 2 : map (+1) (2 : _)
            ^------------<|
    1 : 2 : a : map (+1) (a : _) where a = ((+1) 2)
                ^------------<|
    1 : 2 : 3 : map (+1) (3 : _)
                ^------------<|
    1 : 2 : 3 : a : map (+1) (a : _) where a = ((+1) 3)
                    ^------------<|
    1 : 2 : 3 : 4 : map (+1) (4 : _)
                    ^------------<|

m=1:map（+1）m
1：地图（+1）（1:
^------------谢谢你的回答。这是否意味着，第二个单词中的“map（+1）（1:uu）”本身变成了thunk，第二个单词的thunk变成了第三个单词中的“a:map（+1）…”？但我不太明白是什么让每个thunk严格地指向同一递归级别的映射。它看起来像是前一个thunk范围内的模式匹配，我想。@fangyc是的，
映射（+1）（…）
每次生成新元素时都会成为下一个thunk。另一种方式是将其视为来自面向对象语言的一种工具。它的操作方式大致相同，但这是Haskell中的默认行为，适用于所有类型（特别严格的类型除外）。@fangyc您可能对今天早些时候的帖子感兴趣，其他人的问题与您的问题非常相似，给出的答案显示了您如何实际查看此评估，幸运的是，它与我给出的答案一致。这可能有助于你进一步理解它。我正在利用你提供的信息尝试这个工具。这是伟大的，我已经了解更多。谢谢，谢谢你的回答。这是否意味着，第二个单词中的“map（+1）（1:uu）”本身变成了thunk，第二个单词的thunk变成了第三个单词中的“a:map（+1）…”？但我不太明白是什么让每个thunk严格地指向同一递归级别的映射。它看起来像是前一个thunk范围内的模式匹配，我想。@fangyc是的，
映射（+1）（…）
每次生成新元素时都会成为下一个thunk。另一种方式是将其视为来自面向对象语言的一种工具。它的操作方式大致相同，但这是Haskell中的默认行为，适用于所有类型（特别严格的类型除外）。@fangyc您可能对今天早些时候的帖子感兴趣，其他人的问题与您的问题非常相似，给出的答案显示了您如何实际查看此评估，幸运的是，它与我给出的答案一致。这可能有助于你进一步理解它。我正在利用你提供的信息尝试这个工具。这是伟大的，我已经了解更多。非常感谢。