haskell - 合理的 Comonad 实现

Question

我们可以将 monad 描述为计算上下文，并且 monad 实现准确地保留了该上下文的含义。例如选项 - 上下文含义是值可能存在。给定 Option 数据类型，唯一有意义的实现是 pure = some, flatMap f = {none => none; some x => f x }根据我对 monad 的理解，通过遵循类型签名 - 任何 monad 都只有一种合理的实现。换句话说，如果您想向值/计算添加一些有意义的上下文，对于任何特定的 monad 只有一种方法可以做到这一点。
另一方面，当谈到 comonad 时，它突然开始感觉完全奇怪，就像有很多方法可以为给定类型实现 comonad，您甚至可能为每个实现赋予一定的含义。
考虑一下，NEL，与 copure = head 。 cojoin通过 tails 实现，完全满足类型。如果我们实现cojoin通过permutations或如fa map (_ => fa) map f它不满足comonad 法律。
但是循环实现是有效的:

override def cobind[A, B](fa: NonEmptyList[A])(f: (NonEmptyList[A]) => B): NonEmptyList[B] = {
  val n: NonEmptyList[NonEmptyList[A]] = fa.map(_ => fa).zipWithIndex.map { case (li , i ) =>
    val(h: List[A], t: List[A]) = li.list.splitAt(i)
    val ll: List[A] = t ++ h
    NonEmptyList.nel(ll.head, ll.tail)
  }
  n map f
}

指挥如此模糊的原因是，即使有法律限制我们，在我看来，如果在 Monad 中我们在某些情况下限制自己(我们有点无法“创建”新信息)，那么在 Comonad 中，我们正在进一步扩展这个上下文(有很多方法可以从列表中创建列表列表)，这为我们提供了更多的可能性。在我脑海中的隐喻是:对于 Monad 来说，我们正站在路上，并且想要到达某个目的地点 A = 因此只有有意义的最短路径可供选择。在指挥中，我们站在 A 处，想要从它出发去某个地方，所以有更多的方法可以做到这一点。
所以我的问题是——我真的是对的吗？我们能否以不同的方式实现命令，每次都进行另一个有意义的抽象？或者只有 tails 实现是合理的，因为 comonad 应该引入抽象。

Answer 1

非空列表通过两种标准结构作为两个不同的共形体出现。

首先，给出了cofree comonad。

data Cofree f x = x :& f (Cofree f x)  -- every node is labelled with an x

instance Functor f => Functor (Cofree f) where
  fmap f (x :& fcx) = f x :& fmap (fmap f) fcx

instance Functor f => Comonad (Cofree f) where
  extract (x :& _) = x   -- get the label of the top node
  duplicate cx@(_ :& fcx) = cx :& fmap duplicate fcx

非空列表可以给出为

type Nellist1 = Cofree Maybe

因此自动成为同源的。这给了你“尾部”comonad。

同时，将结构分解为“元件 zipper ”会产生共生结构。正如我explained at great length ,

可区分性相当于对 zipper 的这一系列操作(从上下文中挑选出单个元素并将其置于“焦点”)

class (Functor f, Functor (DF f)) => Diff1 f where
  type DF f :: * -> *
  upF      ::  ZF f x  ->  f x           -- defocus
  downF    ::  f x     ->  f (ZF f x)    -- find all ways to focus
  aroundF  ::  ZF f x  ->  ZF f (ZF f x) -- find all ways to *re*focus

data ZF f x = (:<-:) {cxF :: DF f x, elF :: x}

所以我们得到一个仿函数和一个comonad

instance Diff1 f => Functor (ZF f) where
  fmap f (df :<-: x) = fmap f df :<-: f x

instance Diff1 f => Comonad (ZF f) where
  extract    = elF
  duplicate  = aroundF

原则上，非空列表也由这种构造产生。问题在于，尽管导数是合理的，但要微分的仿函数在 Haskell 中并不那么容易表达。让我们发疯吧...

非空列表相当于 ZF thingy x，其中 DF thingy = []。我们可以整合列表吗？玩弄代数可能会给我们提供线索

[x] = Either () (x, [x]) = 1 + x * [x]

所以作为幂级数，我们得到

[x] = Sum(n :: Nat). x^n

我们可以积分幂级数

Integral [x] dx = Sum(n :: Nat). x^(n+1)/(n+1)

这意味着我们得到了某种大小为 (n+1) 的任意元组，但我们必须根据等价类大小为 (n+1) 的某种关系来识别它们。一种方法是识别旋转之前的元组，因此您不知道 (n+1) 个位置中的哪一个是“第一个”。

也就是说，列表是非空循环的导数。想象一下一群人在圆 table 上玩纸牌(可能是纸牌)。旋转 table ，你就会看到同样一群人在玩牌。但是，一旦您指定了庄家，您就可以从庄家左侧开始按顺时针方向排列其他玩家的列表。

两种标准结构；同一个仿函数的两个共生体。

(在我之前的评论中，我评论了多个 monad 的可能性。这有点复杂，但这是一个起点。每个 monad m 也是适用的，并且适用的法则使得 m () 是一个幺半群。相应地，m () 的每个幺半群结构至少给出了 m 上的 monad 结构的候选者。在以下情况下writer monads (,) s，我们得到 monad 的候选者是 (s,()) 上的幺半群，它们与 上的幺半群完全相同s。)

编辑非空列表在至少两种不同的方面也是单子(monad)。

我定义仿函数的身份和配对，如下所示。

newtype I         x = I x
data    (f :*: g) x = (:&:) {lll :: f x, rrr :: g x}

现在，我可以如下引入非空列表，然后定义串联。

newtype Ne x = Ne ((I :*: []) x)

cat :: Ne x -> Ne x -> Ne x
cat (Ne (I x :&: xs)) (Ne (I y :&: ys)) = Ne (I x :&: (xs ++ y : ys))

这些是一元的，就像可能的空列表一样:

instance Monad Ne where
  return x = Ne (I x :&: [])
  Ne (I x :&: xs) >>= k = foldl cat (k x) (map k xs)

但是，I 是一个单子(monad):

instance Monad I where
  return = I
  I a >>= k = k a

此外，单子(monad)在配对下是封闭的:

instance (Monad f, Monad g) => Monad (f :*: g) where
  return x = return x :&: return x
  (fa :&: ga) >>= k = (fa >>= (lll . k)) :&: (ga >>= (rrr . k))

所以我们可以直接写

newtype Ne x = Ne ((I :*: []) x) deriving (Monad, Applicative, Functor)

但是该 monad 的返回给了我们双重视觉。

return x = Ne (I x :&: [x])

所以你知道了:非空列表有共元两种方式、单元两种方式、应用六种方式，...

(关于这个还有很多话要说，但我必须在某个地方停下来。)