如果MonadPlus是“generator”类，那么“consumer”类是什么？

Question

管道可以分为两部分：发电机部分（产量）和消费者部分（等待）。

如果你有一个Pipe，它只使用它的生成器的一半，并且只返回（）（或者从不返回），那么它可以表示为"ListT做对了"。事实证明，MonadPlus可以用来表示任何类似ListT-dod-right的东西。引用加布里埃尔·冈萨雷斯的话：

请注意，您可以仅使用变压器依赖项构建任何ListT（不仅仅是管道中的那个）。例如，下面是如何实现Pipes的ListT模拟。Prelude.stdinLn：

-- stdinLn :: ListT IO String
stdinLn :: (MonadTrans t, MonadPlus (t IO)) => t IO String
stdinLn = do
    eof <- lift isEOF
    if eof
        then mzero
        else do
            str <- lift getLine
            return str `mplus` stdinLn

这将在那里键入check作为anyListT，并为所有人做正确的事情。

所以我的问题是：对于管道的消费者部分，是否有一个对偶到ListT和到MonadPlus？

要求：

• 从不使用yield，只返回（）（或从不返回），但使用wait的管道可以表示为“双重到列表”
• “dual to ListT”可以概括为“MonadPlus的dual”

Answer 1

我认为答案不是双重化类似生成器的类型类，而是用一个简单的类别实例来扩展它，等效于wait/（

不幸的是，没有办法安排类型变量使其满足所有三个类型类（MonadPlus、MonadTrans、和Category），因此我将定义一个新的类型类：

{-# LANGUAGE KindSignatures #-}

import Control.Monad
import Control.Monad.Trans.Class

class Consumer (t :: * -> (* -> *) -> * -> *) where
    await :: t a m a
    (>~)  :: t a m b -> t b m c -> t a m c

该类型类别的规则为类别规则：

await >~ f = f

f >~ await = f

(f >~ g) >~ h = f >~ (g >~ h)

然后，一旦有了这个额外的类型类，就可以实现消费者s和管道s：

printer :: (Show a, Monad (t a IO), MonadTrans (t a), Consumer t) => t a IO r
printer = do
    a <- await
    lift (print a)
    printer
{-
printer :: Show a => Consumer a IO r
printer = do
    a <- await
    lift (print a)
    printer
-}

cat :: (MonadPlus (t a m), Consumer t) => t a m a
cat = await `mplus` cat
{-
cat :: Monad m => Pipe a a m r
cat = do
    a <- await
    yield a
    cat
-}

debug :: (Show a, MonadPlus (t a IO), MonadTrans (t a), Consumer t) => t a IO a
debug = do
    a <- await
    lift (print a)
    return a `mplus` debug
{-
debug :: Show a => Pipe a a IO r
debug = do
    a <- await
    lift (print a)
    yield a
    debug
-}

taker :: (Consumer t, MonadPlus (t a m)) => Int -> t a m a
taker 0 = mzero
taker n = do
    a <- await
    return a `mplus` taker (n - 1)
{-
taker :: Monad m => Int -> Pipe a a m ()
taker 0 = return ()
taker n = do
    a <- await
    yield a
    taker (n - 1)
-}

困难的部分是弄清楚如何在不向base添加新类型类的情况下做到这一点。如果可能的话，我更喜欢重用原始的类别类型类，可能有等待和（

编辑：我找到了解决办法。只需定义以下新类型：

{-# LANGUAGE KindSignatures, FlexibleContexts #-}

import Control.Category
import Prelude hiding ((.), id)

newtype Consumer t m a b = Consumer { unConsumer :: t a m b }

await :: Category (Consumer t m) => t a m a
await = unConsumer id

(>~) :: Category (Consumer t m) => t a m b -> t b m c -> t a m c
f >~ g = unConsumer (Consumer f >>> Consumer g)

然后，任何库都可以为包装在消费者新类型中的类型实现一个类别实例。

然后，在使用wait或（

cat :: (MonadPlus (t a m), Category (Consumer t m)) => t a m a
cat = await `mplus` cat