为什么这个haskell代码不会终止

Question

import Control.Monad.State.Lazy

type Queue a = [a]

push :: a -> State (Queue a) ()
push x = state (\xs -> ((),xs++[x]))

pop :: State (Queue a) a
pop = state (\(x:xs) -> (x,xs))

queueManip :: State (Queue Int) Int
queueManip =
  do
    mapM_ push [1..]
    a <- pop
    return a

main :: IO()
main = do
  let (a,_) = runState queueManip []
  print a

mapM_ 不应该偷懒吗？除了实现队列之外，复杂度不应该是O(1)吗？

因为附加 (++) 本身是惰性的...

Answer 1

如果我是邪恶的并使用怎么办

push' :: Int -> State (Queue Int) ()
push' 1052602983 = state $ \_ -> ((), []) -- "Muarhar!"
push' x = state $ \xs -> ((),xs++[x])

那么mapM push' [1..] 应该清楚地将状态呈现为[1052602983, 1052602984 ..]。 pop 产生 1 是错误的。但是mapM 不可能知道这一点，除非先评估其他十亿个数字。实际上将它们推到状态在这里是无关紧要的，push 可能完全懒惰也没关系：mapM 至少必须给它一个 机会 来检查任何给定的数字，在处理一元程序流程之前。

Answer 2

注意do mapM_ push [1..3]; something 等同于：

do push 1; push 2; push 3; something

所以这应该解释为什么

do mapM_ push [1..]; something

从不执行something。

如果你看一下 State monad 的定义：

type State s a = s -> (a, s)

instance Monad (State s) where
  return a = \s -> (a,s)
  m >>= g = wpAB
    where
      wpAB = \s1 -> let (v2, s2) = m s1
                        (v3, s3) = g v2 s2
                    in (v3, s3)

-- (newtypes and such have been removed to declutter the code)

您会看到m >>= g 的值始终取决于g。对比Maybemonad的定义：

instance Monad Maybe where
    return x = Just x
    (>>=) m g = case m of
                  Nothing -> Nothing
                  Just x  -> g x

其中m >>= g 可以独立于g，这解释了Maybe monad 如何使do-chain 短路。