haskell - Monoidal Functor 是 Applicative 但 Applicative 定义中的 Monoid 类型类在哪里？

Question

Applicative 是一个 Monoidal Functor :

mappend :: f         -> f   -> f
$       ::  (a -> b) ->   a ->   b
<*>     :: f(a -> b) -> f a -> f b

但是我在 Applicative 类型类的定义中没有看到任何关于 Monoid 的引用，你能告诉我为什么吗？

定义 :

class Functor f => Applicative (f :: * -> *) where
  pure :: a -> f a
  (<*>) :: f (a -> b) -> f a -> f b
  GHC.Base.liftA2 :: (a -> b -> c) -> f a -> f b -> f c
  (*>) :: f a -> f b -> f b
  (<*) :: f a -> f b -> f a
  {-# MINIMAL pure, ((<*>) | liftA2) #-}

此定义中没有提及结构 Monoid，但是当您这样做时

> ("ab",(+1)) <*> ("cd", 5) 
>("abcd", 6)

在实现这个 Applicative 实例时，您可以清楚地看到结构 Monoid "(,) String"的使用。

另一个显示使用“结构 Monoid”的示例:

Prelude Data.Monoid> (2::Integer,(+1)) <*> (1::Integer,5)

<interactive>:35:1: error:
    • Could not deduce (Monoid Integer) arising from a use of ‘<*>’
      from the context: Num b
        bound by the inferred type of it :: Num b => (Integer, b)
        at <interactive>:35:1-36
    • In the expression: (2 :: Integer, (+ 1)) <*> (1 :: Integer, 5)
      In an equation for ‘it’:
          it = (2 :: Integer, (+ 1)) <*> (1 :: Integer, 5)

Answer 1

“monoidal functor”所指的幺半群不是 Monoid幺半群，即值(value)级别的幺半群。它是一个类型级的幺半群。即，无聊的产品幺半群

type Mempty = ()
type a <> b = (a,b)

(您可能会注意到，严格来说这不是一个幺半群；只有当您将 ((a,b),c) 和 (a,(b,c)) 视为同一类型时。它们确实是同构的。)

看看这与 Applicative 有什么关系, 分别monoidal 仿函数，我们需要用其他术语来编写类。

class Functor f => Monoidal f where
  pureUnit :: f Mempty
  fzip :: f a -> f b -> f (a<>b)

-- an even more “general nonsense”, equivalent formulation is
-- upure :: Mempty -> f Mempty
-- fzipt :: (f a<>f b) -> f (a<>b)
-- i.e. the functor maps a monoid to a monoid (in this case the same monoid).
-- That's really the mathematical idea behind this all.

IOW

class Functor f => Monoidal f where
  pureUnit :: f ()
  fzip :: f a -> f b -> f (a,b)

定义标准 Applicative 的通用实例是一个简单的练习。类 Monoidal ， 反之亦然。

关于 ("ab",(+1)) <*> ("cd", 5) : 这与 Applicative 没有太大关系一般而言，但仅适用于作家的具体应用。实例是

instance Monoid a => Monoidal ((,) a) where
  pureUnit = (mempty, ())
  fzip (p,a) (q,b) = (p<>q, (a,b))