为什么相互让步使 ArrowApply 和 Monads 等效，而不像 Arrow 和 Applicative？

这是我要参考的SO帖子 https://stackoverflow.com/a/24668518/11143763. 另外，我将使用与该问题中的OP相同的片段，以免分离材料 https://stackoverflow.com/q/24668313/11143763.

It is 众所周知 https://hackage.haskell.org/package/base-4.12.0.0/docs/src/Control.Arrow.html#ArrowApply那一个ArrowApply实例产生一个 Monad，反之亦然：

newtype ArrowMonad a b = ArrowMonad (a () b)

instance Arrow a => Functor (ArrowMonad a) where
    fmap f (ArrowMonad m) = ArrowMonad $ m >>> arr f

instance Arrow a => Applicative (ArrowMonad a) where
   pure x = ArrowMonad (arr (const x))
   ArrowMonad f <*> ArrowMonad x = ArrowMonad (f &&& x >>> arr (uncurry id))

instance ArrowApply a => Monad (ArrowMonad a) where
    ArrowMonad m >>= f = ArrowMonad $
        m >>> arr (\x -> let ArrowMonad h = f x in (h, ())) >>> app

newtype Kleisli m a b = Kleisli { runKleisli :: a -> m b }

instance Monad m => Category (Kleisli m) where
    id = Kleisli return
    (Kleisli f) . (Kleisli g) = Kleisli (\b -> g b >>= f)

instance Monad m => Arrow (Kleisli m) where
    arr f = Kleisli (return . f)
    first (Kleisli f) = Kleisli (\ ~(b,d) -> f b >>= \c -> return (c,d))
    second (Kleisli f) = Kleisli (\ ~(d,b) -> f b >>= \c -> return (d,c))

直到我偶然发现post https://stackoverflow.com/a/24668518/11143763上面提到，我觉得这个片段是等价的合理证明ArrowApply and Monad类。然而，拥有这样的知识事实上，箭头和应用并不等同 https://stackoverflow.com/a/24668518/11143763下面的代码片段让我对等价性的完整证明感到好奇Monad and ArrowApply:

newtype Arrplicative arr o a = Arrplicative{ runArrplicative :: arr o a }

instance (Arrow arr) => Functor (Arrplicative arr o) where
    fmap f = Arrplicative . (arr f .) . runArrplicative

instance (Arrow arr) => Applicative (Arrplicative arr o) where
    pure = Arrplicative . arr . const

    Arrplicative af <*> Arrplicative ax = Arrplicative $
        arr (uncurry ($)) . (af &&& ax)

newtype Applicarrow f a b = Applicarrow{ runApplicarrow :: f (a -> b) }

instance (Applicative f) => Category (Applicarrow f) where
    id = Applicarrow $ pure id
    Applicarrow g . Applicarrow f = Applicarrow $ (.) <$> g <*> f

instance (Applicative f) => Arrow (Applicarrow f) where
    arr = Applicarrow . pure
    first (Applicarrow f) = Applicarrow $ first <$> f

因此，如果您往返应用程序，您会失去一些功能。 https://stackoverflow.com/q/24668313/11143763

写下的示例很明显，但我无法理解通过 Monad 的“往返”如何保留所有 ArrowApply 功能，因为最初我们有一个取决于某些输入的箭头（a b c）但最终，我们最终得到了一个强制进入包装器的箭头，该包装器以单位类型作为其输入类型（ArrowMonad (a () b)).

很明显，我在这里做了一些非常错误的事情，但我无法理解到底是什么。

充分的证明是什么ArrowApply and Monad是等价的？

不等价的例子有哪些Arrow and Applicative占？一个人是否概括了另一个人？

箭头微积分和范畴论对整个情况的解释是什么？

我希望得到完整的解释和提示，它们可以帮助人们自己起草一份看似合理的证据。

因为最初我们有一个箭头，它取决于一些输入（a b c）但最终，我们最终得到了一个强制进入包装器的箭头，该包装器以单位类型作为其输入类型（ArrowMonad (a () b))

我想这就是令人困惑的中心点，而且确实令人困惑。我喜欢将箭头视为笛卡尔幺半群范畴中的态射，你不会明白这一点，但已经Arrow类实际上比这更受限制，这要归功于arr– 这给你一个函子Hask进入类别。但是，有点令人惊讶的是，这还需要您在other方向：任何箭头都可以替换为function这仅产生一个平凡域的箭头。具体来说，

arrAsFunction :: Arrow k => k x y -> (x -> k () y)
arrAsFunction φ x = φ <<< arr (const x)

好吧，仅此一点并不算太具有开创性——也许我们只是在这里丢弃了一些信息？ – 但与ArrowApply这实际上是一个同构：您可以通过以下方式取回原始箭头

retrieveArrowFromFunction :: ∀ k x y .
          ArrowApply k => (x -> k () y) -> k x y
retrieveArrowFromFunction f = arr f' >>> app
 where f' :: x -> (k () y, ())
       f' x = (f x, ())

...这正是在中使用的Monad (ArrowMonad a)实例。

所以结果是：arr，通过要求您可以在类别中嵌入任何 Haskell 函数，强制类别基本上归结为对结果进行一些包装的函数，IOW 类似 Kleisli 箭头的东西。

查看其他一些范畴论层次结构，看看这是not笛卡尔幺半群范畴的基本特征，但实际上是Hask → k函子。例如。在受限类别中 http://hackage.haskell.org/package/constrained-categories-0.4.0.0/docs/Control-Arrow-Constrained.html#t:PreArrow我已经密切反映了标准课程，PreArrow作为笛卡尔幺半群类别的类，但故意保留arr并没有具体说明Hask，因为这大大降低了该类别的功能，并导致它几乎等同于Hask-克莱斯利。