帮助编写“colist Monad”（习语介绍论文中的练习）

Question

我正在阅读 Conor McBride 和 Ross Paterson 的“Functional Pearl / Idioms: applicative programming with effects:”（new 版本，标题中带有“idioms”）。我在练习 4 中遇到了一点困难，下面将对此进行解释。任何提示将不胜感激（特别是：我应该开始写fmap 和join 还是return 和>>=？）。

问题陈述

你想在哪里创建一个instance Monad []

return x = repeat x

和ap = zapp。

标准库函数

如第 p.论文的 2，ap 将一元函数值应用于一元值。

ap :: Monad m => m (s -> t) -> m s -> m t
ap mf ms = do
    f <- mf
    s <- ms
    return (f s)

我用规范符号将其扩展为，

ap mf ms = mf >>= (\f -> (ms >>= \s -> return (f s)))

特定于列表的函数zapp（“zippy 应用程序”）将一个列表中的函数应用于另一个列表中的对应值，即，

zapp (f:fs) (s:ss) = f s : zapp fs ss

我的困难

请注意，在扩展形式中，mf :: m (a -> b) 在我们的例子中是函数[(a -> b)] 的列表。所以，在>>=的第一个应用中，我们有

(f:fs) >>= mu

在哪里mu = (\f -> (ms >>= \s -> return (f s)))。现在，我们可以将fs >>= mu 作为子程序调用，但这并不知道要删除ms 的第一个元素。 （回想一下，我们希望结果列表是 [f1 s1, f2 s2, ...]。我试图破解一些东西，但是......正如预期的那样，它没有用......任何帮助将不胜感激。

提前致谢！

编辑 1

我想我已经成功了；首先，我按照用户“comonad”的建议，用 fmap 和 join 重写了 ap。

我的信念飞跃假设fmap = map。如果有人能解释如何到达那里，我将非常感激。在此之后，很明显join 在用户“comonad”建议的列表列表中起作用，并且应该是对角线\x -> zipWith ((!!) . unL) x [0..]。我的完整代码是这样的：

newtype L a = L [a] deriving (Eq, Show, Ord)
unL (L lst) = lst
liftL :: ([a] -> [b]) -> L a -> L b
liftL f = L . f . unL

joinL :: L (L a) -> L a
joinL = liftL $ \x -> zipWith ((!!) . unL) x [0..]

instance Functor L where
    fmap f = liftL (map f)

instance Monad L where
    return x = L $ repeat x
    m >>= g = joinL (fmap g m)

希望是对的（似乎是论文第 18 页上的“解决方案”）...谢谢大家的帮助！

Answer 1

我只是想我应该澄清一下，标题中带有练习和“成语”的版本是该论文的一个相当较早的草稿，最终出现在 JFP 中。那时，我错误地认为 colists （我的意思是可能是无限的，可能是有限的列表）是一个对应于 zapp 的单子：有一个合理的连接候选者（在其他答案中提到）但是 Jeremy Gibbons很友好地向我们指出它不满足单子定律。反例涉及具有不同有限长度的列表的“参差不齐”列表。相应地，在 JFP 文章中，我们得到了纠正。 （我们对此非常高兴，因为我们喜欢找到 () 不是 Monad 的 ap 的应用函子。）

必然无限的列表（即streams），通过排除不规则的情况，确实形成了一个monad，其ap 的行为类似于zapp。作为线索，请注意 Stream x 与 Nat -> x 同构。

对于造成的混乱，我深表歉意。将旧的、未完成的草稿（充满错误）留在网上（哈哈）有时很危险。

Answer 2

Monad 的最小完整定义是fmap+return+join 或return+(>>=)。您可以将一个与另一个一起实现：

(>>=) :: Monad m => m a -> (a->m b) -> m b
(>>=) ma amb = join $ fmap amb ma

fmap :: Monad m => (a->b) -> m a -> m b
fmap f ma = ma >>= (return . f)
join :: Monad m => m (m a) -> m a
join mma = mma >>= id

现在，ap 的实现可以重写为join 和fmap：

ap :: Monad m => m (a->b) -> m a -> m b
ap mf ma = do
    f <- mf
    a <- ma
    return (f a)
ap mf ma = do
    f <- mf
    fmap f ma
ap mf ma = join $ fmap (flip fmap ma) mf

---

在练习中，给出了fmap和return和ap的语义。 其余的一目了然，只要您检查一个示例即可：

ap [f1,f2,f3...] [1,2,3...] = join $ fmap (flip fmap [1,2,3...]) [f1,f2,f3...]
                            = join $ [ [(f1 1), f1 2 , f1 3 ...]
                                     , [ f2 1 ,(f2 2), f2 3 ...]
                                     , [ f3 1 , f3 2 ,(f3 3)...]
                                     ...
                                     ]
                            = [(f1 1)
                              ,     (f2 2)
                              ,          (f3 3)
                              ...
                              ]

Answer 3

嗯。我不禁认为这个练习有点不公平。

练习 4（colist Monad）

虽然repeat 和zapp 不是通常的Monad [] 实例的return 和ap， 它们仍然是替代 monad 的 return 和 ap，更适合 [] 的同义解释。这个 monad 的 join :: [[x]] → [x] 是什么？

评论这个 monad 的 ap 和我们的 zapp 的相对效率。

首先，我相当确定所讨论的 monad 实例一般对 [] 无效。当他们说“共归纳解释”时，我怀疑这是指无限列表。在某些情况下，该实例实际上对有限列表有效，但通常不适用于任意列表。

这是您的第一个非常笼统的提示——为什么 monad 实例只对某些列表有效，尤其是无限列表？

这是您的第二个提示：考虑到本文前面的其他定义，fmap 和 return 是微不足道的。你已经有return； fmap 只是稍微不那么明显。

此外，(>>=) 在其他功能方面也很容易实现，就像任何Monad 一样，这使得join 成为问题的症结所在。在大多数情况下，(>>=) 更适合编程，但join 在概念上更基础，在这种情况下，我认为更易于分析。所以我建议继续努力，暂时忘记(>>=)。一旦你有了一个实现，你就可以返回并重建(>>=) 并检查 monad 法则以确保它一切正常。

最后，假设您有fmap 可用，但没有别的。给定类型为[a -> b] 和[a] 的值，您可以将它们组合起来得到[[b]] 类型的东西。这里join的类型是[[a]] -> [a]。您如何编写 join 以便在此处获得与在原始值上使用 zapp 相同的结果？请注意，关于相对效率的问题和问题一样，是关于实现的线索。