如果枚举器尝试消耗输入会发生什么？

Question

Enumerator 是：

type Enumerator a m b = Step a m b -> Iteratee a m b

文档指出，虽然 Iteratee 使用数据，Enumerator 生成数据。我可以理解如何生成具有这种类型的数据：

enumStream :: (Monad m) => Stream a -> Enumerator a m b
enumStream stream step =
    case step of
        Continue k -> k stream
        _          -> returnI step  -- Note: 'stream' is discarded

_{(enumEOF 比这更复杂......它显然会检查以确保 Iteratee 不给出 EOF 后继续，如果出现则抛出错误。）}

即，Iteratee 生成 步骤当它使用 runIteratee 运行。然后这个Step被输入到我的枚举器，它为它提供一个Stream以便它可以继续。我的枚举器返回结果延续。

有一点对我来说很突出：这段代码在 Iteratee monad 中运行。这意味着它可以消耗数据，对吗？

-- | Like 'enumStream', but consume and discard a chunk from the input stream
--   simply because we can.
enumStreamWeird :: (Monad m) => Stream a -> Enumerator a m b
enumStreamWeird stream step = do
    _ <- continue return            -- Look, mommy, I'm consuming input!
    case step of
        Continue k -> k stream
        _          -> returnI step

该文档指出，当枚举器同时充当源和接收器时， Enumeratee 应该改用：

type Enumeratee ao ai m b = Step ai m b -> Iteratee ao m (Step ai m b)

但是，显然我不必这样做；我可以使用 Enumerator 定义中的输入，如我的 enumStreamWeird 函数所示。

我的问题是：

• 如果您尝试在 Enumerator 中“使用”数据，就像 enumStreamWeird 那样，会发生什么？数据从哪里来？

• 即使我们还没有疯狂到消耗枚举器中的数据，代表枚举器而不是代表读取我们正在生成的数据的迭代器在底层 monad 中执行操作是否有效？

后一个问题可能与我的主要问题不太相关，但我试图了解 Enumerator 是如何完成它的工作的。

Answer 1

是的，枚举器可以消耗数据。枚举器基本上采用一个迭代器，并在输入一些项目后将其转换为相同的迭代器。如果枚举器要求输入，则生成的迭代器将要求输入。

如何将枚举器提供给迭代器

让我们看看如何将枚举器提供给迭代器：

-- | Feed an Enumerator to an Iteratee.
feed :: Monad m
     => Iteratee a m b
     -> Enumerator a m b
     -> Iteratee a m b
feed iteratee enumerator =
    Iteratee $ do
        step <- runIteratee iteratee
        runIteratee $ enumerator step

_{注意：feed 是 >>==.}

首先，feed 运行 iteratee，直到它准备好输入。然后，它传递迭代器的第一个 步骤到枚举器。枚举器从那里接管。

最后一句话非常重要。枚举器可以对其迭代器做任何它想做的事情。如果愿意的话，它可以完全丢弃 iteratee。然而，枚举器通常向迭代器提供它所拥有的输入，然后将控制权交还给迭代器。

示例 1：向迭代器提供枚举器

假设我们有一个迭代器，它请求三个字符串并打印它们：

iter3 :: Iteratee String IO ()
iter3 = do
    lift $ putStrLn "Gimmie a string!"
    a <- head_
    lift $ putStrLn a
    lift $ putStrLn "Gimmie another string!"
    b <- head_
    lift $ putStrLn b
    lift $ putStrLn "Gimmie one more string!"
    c <- head_
    lift $ putStrLn c
    lift $ putStrLn "Thank you!"

_{head_ 定义于 Data.Enumerator.List .}

和一个为其 iteratee 提供单个字符串的枚举器：

getString :: Enumerator String IO a
getString (Continue k) = do
    line <- lift getLine
    k (Chunks [line])
getString step = Iteratee $ return step

当为 getString 提供一个需要多个项目的 iteratee 时，它​​将向 iteratee 提供第一个项目。然后，getString 本身将需要剩余的项目。

• iter3 需要三个项目才能返回 ()。

• iter3 `feed` getString 需要两项。

• iter3 `feed` getString `feed` getString 需要一项。

• iter3 `feed` getString `feed` getString `feed` getString 不再需要任何项目。

• iter3 `feed` getString `feed` getString `feed` getString `feed` getString 与上面等效。这是由 getString 的第二种情况处理的。

示例 2：消耗输入的枚举器

考虑一个消耗输入的枚举器：

consumeEnum :: Enumerator String IO a
consumeEnum step = do
    lift $ putStrLn "I take without giving"
    _ <- head_
    Iteratee $ return step

iter3 `feed` ConsumerEnum 做什么？这可以通过查看consumeEnum自己的实现来回答。首先它需要一个项目并丢弃它。然后它将火炬交给 iter3，它还需要三个项目。

不过，请回头看看 feed 组合器。它首先运行 iter3，然后传递其 步骤到consumeEnum。这意味着 "Gimmie a string!" 将在控制到达 consumeEnum 之前打印。

Answer 2

枚举器消耗数据没有任何问题。它是一个 iteratee 转换器，很可能将自己的输入输入到 iteratee 中。查看将枚举器应用于迭代器的方式。您还可以将另一个枚举器应用于应用于枚举器的迭代器。