问题
一般来说，为了使 IO 动作正确排序并以可预测的方式运行，每个动作都需要在运行下一个动作之前完全完成。在 do-block 中，这意味着它可以工作：
main = do
sequence (map putStrLn ["This","action","will","complete"])
putStrLn "before we get here"
但不幸的是，如果最后的 IO 操作很重要，这将不起作用：
dontRunMe = do
putStrLn "This is a problem when an action is"
sequence (repeat (putStrLn "infinite"))
putStrLn "<not printed>"
所以，即使sequence 可以专门用于正确的类型签名：
sequence :: [IO a] -> IO [a]
它在无限的 IO 操作列表中无法正常工作。您定义这样的序列没有问题：
badSeq :: IO [Char]
badSeq = sequence (repeat (return '+'))
但任何执行 IO 操作的尝试（例如，通过尝试打印结果列表的头部）都会挂起：
main = (head <$> badSeq) >>= print
您是否只需要结果的部分也没关系。在整个 sequence 完成之前，您不会从 IO monad 中得到任何东西（如果列表是无限的，则“永远不会”）。
“延迟 IO”解决方案
如果您想从部分完成的 IO 操作中获取数据，则需要明确说明并使用听起来很吓人的 Haskell 逃生舱口，unsafeInterleaveIO。此函数接受一个 IO 操作并“延迟”它，以便在需要该值之前它不会真正执行。
这通常是不安全的原因是，现在有意义的 IO 操作，如果在以后的时间点实际执行，可能意味着不同的东西。举个简单的例子，截断/删除文件的 IO 操作如果在之前和在更新文件内容写入之后执行，其效果会非常不同！
不管怎样，你要做的就是写一个懒惰的sequence：
import System.IO.Unsafe (unsafeInterleaveIO)
lazySequence :: [IO a] -> IO [a]
lazySequence [] = return [] -- oops, not infinite after all
lazySequence (m:ms) = do
x <- m
xs <- unsafeInterleaveIO (lazySequence ms)
return (x:xs)
这里的重点是，当一个lazySequence infstream动作被执行时，它实际上只会执行第一个动作；剩余的操作将被包裹在一个延迟的 IO 操作中，直到返回列表的第二个和后续元素被要求时才会真正执行。
这适用于虚假 IO 操作：
> take 5 <$> lazySequence (repeat (return ('+'))
"+++++"
>
（如果您将lazySequence 替换为sequence，它将挂起）。它也适用于真正的 IO 操作：
> lns <- lazySequence (repeat getLine)
<waits for first line of input, then returns to prompt>
> print (head lns)
<prints whatever you entered>
> length (head (tail lns)) -- force next element
<waits for second line of input>
<then shows length of your second line before prompt>
>
无论如何，使用lazySequence 的定义和类型：
parse :: [ByteString] -> [Object]
input :: [IO ByteString]
你应该没有问题写作：
outputs :: IO [Object]
outputs = parse <$> lazySequence inputs
然后随心所欲地懒惰地使用它：
main = do
objs <- outputs
mapM_ doSomethingWithObj objs
使用导管
尽管上述惰性 IO 机制非常简单明了，但由于资源管理问题、空间泄漏方面的脆弱性（对代码稍作改动会导致内存占用），以及异常处理问题。
一个解决方案是conduit 库。另一个是pipes。两者都是精心设计的流媒体库，可以支持无限流。
对于conduit，如果您有一个为每个字节字符串创建一个对象的解析函数，例如：
parse1 :: ByteString -> Object
parse1 = ...
然后给出：
inputs :: [IO ByteString]
inputs = ...
useObject :: Object -> IO ()
useObject = ...
管道看起来像：
import Conduit
main :: IO ()
main = runConduit $ mapM_ yieldM inputs
.| mapC parse1
.| mapM_C useObject
鉴于您的解析函数具有签名：
parse :: [ByteString] -> [Object]
我很确定您不能直接将其与管道集成（或者至少不能以任何不会放弃使用管道的所有好处的方式）。您需要对其进行重写，使其在使用字节字符串和生成对象的方式上对管道友好。