我正在阅读“A Gentle Introduction to Haskell”,并在早期使用了这个示例,该示例在 GHC 中运行良好,但在我的大脑中却很糟糕:
initial = 0
next resp = resp
process req = req+1
reqs = client initial resps
resps = server reqs
server (req:reqs) = process req : server reqs
client initial ~(resp:resps) = initial : client (next resp) resps
和调用代码:
take 10 reqs
我怎么看,是
reqs
被调用,产生对 client
的调用参数为 0 和 resps
.因此不会resps
现在需要调用...它又调用 reqs
再次?这一切似乎都是无限的......如果有人能详细说明它是如何工作的,我将不胜感激!
最佳答案
我发现手动计算小型 Haskell 程序的行为通常是值得的。评估规则非常简单。要记住的关键是 Haskell 是非严格的(也称为惰性):仅在需要时才计算表达式。懒惰是看似无限的定义可以产生有用结果的原因。在这种情况下,使用 take
意味着我们只需要无限列表的前 10 个元素 reqs
: 它们是我们“需要”的全部。
实际上,“需要”通常由模式匹配驱动。例如,列表表达式通常会被计算到我们可以区分 []
的程度。和 (x:xs)
在功能应用之前。 (请注意,在模式之前的“~
”,就像在 client
的定义中一样,使它变得懒惰(或无可辩驳):在强制整个表达式之前,懒惰模式不会强制其参数。)
记住 take
是:
take 0 _ = []
take n (x:xs) = x : take (n-1) xs
评价
take 10 reqs
好像:take 10 reqs
-- definition of reqs
= take 10 (client initial resps)
-- definition of client [Note: the pattern match is lazy]
= take 10 (initial : (\ resp:resps' -> client (next resp) resps')
resps)
-- definition of take
= initial : take 9 ((\ resp:resps' -> client (next resp) resps')
resps)
-- definition of initial
= 0 : take 9 ((\ resp:resps' -> client (next resp) resps')
resps)
-- definition of resps
= 0 : take 9 ((\ resp:resps' -> client (next resp) resps')
(server reqs))
-- definition of reqs
= 0 : take 9 ((\ resp:resps' -> client (next resp) resps')
(server (client initial resps)))
-- definition of client
= 0 : take 9 ((\ resp:resps' -> client (next resp) resps')
(server (initial : {- elided... -}))
-- definition of server
= 0 : take 9 ((\ resp:resps' -> client (next resp) resps')
(process initial : server {-...-}))
-- beta reduction
= 0 : take 9 (client (next (process initial)) (server {-...-})
-- definition of client
= 0 : take 9 (next (process initial) : {-...-})
-- definition of take
= 0 : next (process initial) : take 8 {-...-}
-- definition of next
= 0 : process initial : take 8 {-...-}
-- definition of process
= 0 : initial+1 : take 8 {-...-}
-- definition of initial
= 0 : 1 : take 8 {-...-}
-- and so on...
关于haskell - 相互递归——有人可以帮助解释这段代码是如何工作的吗?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/397341/