Haskell: TCO与懒散评估

Question

我试图理解为什么当第一个main无效时，当第二个c终止时，第一个c不终止。从描述中看，here main只是一个未评估的thunk，而executing只是在构建数据结构。我试图在这里应用同样的原则，看看为什么第一个main不终止。如果有人能帮我理解这部分，或者给我指点来理解这一点，那就太好了。除此之外，为什么GHCI不能将其识别为TCO？不符合定义吗？

main = loop                                                                     
  where                                                                         
   loop =  do                                                                   
     c <- getChar                                                               
     case valid c of                                                            
       Nothing -> return ()                                                     
       Just b  -> print b                                                       
     print c                                                                    
     loop                                                                       

> main :: IO ()
> main = loop
>   where
>   loop =  do
>     c <- getChar
>     case validate c of
>       Nothing -> return ()
>       Just b  -> do
>         print b
>         loop

谢谢。

Answer 1

尾叫优化与无关，与这种行为无关。问题很简单，第一个代码包含一个无限循环，而第二个没有。

您的第一段代码类似于命令式(类似python)：

def loop():
    c = getChar()
    if valid c:
        do_something()
    else:
        do_something_else()

    print(c)
    loop()

后者类似于：

def loop():
    c = getChar()
    if valid c:
        do_something()
    else:
        do_something_else()
        print(c)
        loop()

注意，在后一种情况下，对loop()的调用在分支else中，而在前者中，它是在外部调用的，因此在每次loop调用时都会调用。

还请注意，Haskell中的return执行而不是终止函数调用。这只是一个IO动作，它有一定的价值，没有副作用。

例如：

main = do
    c <- return 1
    print c

在上面的代码中，return做而不是阻止来自print的输出。