Что произойдет, если Enumerator попытается использовать вход?

Определение Enumerator:

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

В документации указано, что в то время как Iteratee данные comsume, 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 не выполнял Continue после отправки EOF, вызывая ошибку, если это произойдет.)}

А именно, Iteratee создает Step, когда он запускается с runIteratee. Этот Step затем подается в мой счетчик, который снабжает его Stream, чтобы он мог продолжить. Мой перечислитель возвращает полученное продолжение.

Одна вещь выделяется на меня: этот код работает в монаде Iteratee. Это означает, что он может потреблять данные, верно?

-- | 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? Откуда берутся данные?
Даже если мы недостаточно сумасшедшие, чтобы потреблять данные в перечислителе, действительно ли он действителен для выполнения действий в основной монаде от имени перечислителя, а не от имени итератора, читающего данные, репродукция?

Последний вопрос может быть менее связан с моим главным вопросом, но я пытаюсь понять, как Enumerator делает то, что он делает.

Ответ 1

Да, перечислитель может использовать данные. Перечислитель в основном принимает итерацию и преобразует ее в одну итерацию после того, как ее накормили некоторые элементы. Если перечислитель запрашивает ввод, то полученный итератор будет запрашивать ввод.

Как перечислитель пересылается в Iteratee

Посмотрим, как перечислитель пересылается в iteratee:

-- | 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 запускает итерацию, пока она не будет готова для ввода. Затем он передает итератору первый Step в счетчик. Перечислитель переходит оттуда.

Последнее предложение очень важно. Перечислитель может делать все, что захочет, с его итерацией. Он может полностью отказаться от итерации, если захочет. Тем не менее, перечислитель обычно передает итератору свой вход, а затем передает его обратно в итерацию.

Пример 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. Список.суб >}

и перечислитель, который передает его итерацию одной строкой:

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

Когда getString задается итерация, которая требует более одного элемента, она будет кормить итерацию первым элементом. Тогда самому 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` consumeEnum? На это можно ответить, посмотрев на собственную реализацию consumeEnum. Сначала ему нужен элемент и отбрасывает его. Затем он передает факел на iter3, для которого требуется еще три элемента.

Однако вернемся к комбинатору feed. Он начинается с запуска iter3, затем передает Step значение consumeEnum. Это означает, что "Gimmie a string!" будет напечатано до того, как управление достигнет consumeEnum.

Ответ 2

Нет ничего плохого в том, что перечислитель использует данные. Это итерационный трансформатор, который вполне может подавать свой собственный вклад в его итерацию. Посмотрите, как вы применяете перечислитель к итерации. Вы также можете применить другой перечислитель к итератору, примененному к счетчику.