回想一下Applicative类：

class Functor f => Applicative f where
    pure :: a -> f a
    liftA2 :: (a -> b -> c) -> f a -> f b -> f c
    (<*>) :: f (a -> b) -> f a -> f b

    liftA2 h x y = fmap h x <*> y
    (<*>) = liftA2 id

虽然还不清楚如何用（数学）范畴论来表达这个类，但当定义以下函数时，它就变得清晰了：

liftZ2 :: Applicative f => (f a, f b) -> f (a, b)
liftZ2 (x, y) = liftA2 (,) x y

在这里，(,)应该被识别为分类产品。将乘积替换为余积并反转所有箭头，得到以下类：

class Functor f => Coapplicative f where
    copure :: f a -> a
    coliftZ2 :: f (Either a b) -> Either (f a) (f b)

一些示例：

import Data.Functor.Identity
import qualified Data.List.NonEmpty as NonEmpty
import Data.Either

instance Coapplicative Identity where
    copure (Identity x) = x
    coliftZ2 (Identity (Left x)) = Left (Identity x)
    coliftZ2 (Identity (Right y)) = Right (Identity y)

instance Coapplicative NonEmpty.NonEmpty where
    copure (x NonEmpty.:| _) = x
    coliftZ2 (Left x NonEmpty.:| xs) = Left (x NonEmpty.:| lefts xs)
    coliftZ2 (Right y NonEmpty.:| ys) = Right (y NonEmpty.:| rights ys)

instance Coapplicative ((,) e) where
    copure (_, x) = x
    coliftZ2 (e, Left x) = Left (e, x)
    coliftZ2 (e, Right y) = Right (e, y)

instance Monoid m => Coapplicative ((->) m) where
    copure f = f mempty
    coliftZ2 f = case copure f of
        Left x -> Left (fromLeft x . f)
        Right y -> Right (fromRight y . f)

我有一种强烈的直觉，Coapplicative是Comonad的超类，但我不知道如何证明这一点。另外，是否存在不是Comonad的Coapplicative示例？