Question

WrappedArrow是Applicative的一个实例，但它可以设为Monad（可能是箭头为ArrowApply）？

instance ArrowApply a => Monad (WrappedArrow a b) where
  return = pure
  (>>) = (*>)
  (>>=) = ???

编辑：

我最初的目的是让（包裹）Kleisli有一个Monad实例，所以我可以写

runWithInput input $ do
  action1
  action2
  action3
  ...

而不是

do
  output1 <- action1 input
  output2 <- action2 output1
  output3 <- action3 output2
  ...

但我意识到这不会有理想的意义。剥离了新类型，Kleisli f a b >> Kleisli f a c是

(a -> f b) -> (a -> f c) -> (a -> f c)

我需要的是>>>的模拟，即 b 而不是第二a：

(a -> f b) -> (b -> f c) -> (a -> f c)

所以我想如果我想用StateT以这种方式对动作进行排序，我将不得不使用do或自定义monad。

Answer 1

由于这是一个XY问题，我会回答您提出的问题以及您可能想问的问题：

WrappedArrow是Applicative的一个实例，但它可以设为Monad（可能是箭头为ArrowApply）？

是的，可以，但您需要更多限制。事实上，我认为有几种方法可以做到这一点。例如，您可以采用@ user2407038建议的方法：

class Arrow a => ArrowSwap a where
  swap :: a b (a c d) -> a c (a b d)

instance (ArrowApply a, ArrowSwap a) => Monad (WrappedArrow a b) where
  return = pure
  WrapArrow m >>= f = WrapArrow $ swap (arr (unwrapArrow . f)) &&& m >>> app

您可以通过ArrowSwap

的实例为(->)获得一些直觉

instance ArrowSwap (->) where
  swap :: (b -> (c -> d)) -> c -> b -> d
  swap = flip

当然，我们并不清楚这是否有用......

我最初的目的是让（包裹）Kleisli有一个Monad实例，所以我可以写
runWithInput input $ do
  action1
  action2
  action3
  ...
而不是
do
  output1 <- action1 input
  output2 <- action2 output1
  output3 <- action3 output2
  ...

这是RebindableSyntax的用途：

 {-# LANGUAGE RebindableSyntax #-}

 import Control.Monad (>=>)

 action1 :: Monad m => T1 -> m T2
 action2 :: Monad m => T2 -> m T3
 action3 :: Monad m => T3 -> m T4

 action4 :: Monad m => T1 -> m T4
 action4 = let (>>) = (>=>) in do
   action1
   action2
   action3

Answer 2

WrappedArrow是Applicative的一个实例，但它可以设为Monad（可能是箭头为ArrowApply）？

我会暂时搁置WrappedArrow并考虑一个微妙的不同问题＆＃34;我们能否成功实施instance ArrowApply y => Monad (y r)？＆＃34;。这个问题的答案是＆＃34;是＆＃34;。展示它的一种方法依赖于ArrowMonad新型chi提及......

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

...以及以下同构（参见this cstheory.SE question和Idioms are oblivious, arrows are meticulous, monads are promiscuous的第18页）：

kleislify :: ArrowApply y => y r a -> (r -> y () a)
kleislify af = \r -> arr (const r) >>> af

unkleislify :: ArrowApply y => (r -> y () a) -> y r a
unkleislify f = arr f &&& arr (const ()) >>> app

-- unkleislify . kleislify = kleislify . unkleislify = id

ArrowMonad为我们提供了一个monad实例，我们可以通过kleislify使用箭头并为生成的函数提供一个公共参数（换句话说，我们使用的是ArrowMonad通过函数的应用实例绑定：

bindY :: ArrowApply y => y r a -> (a -> y r b) -> y r b
bindY af h = unkleislify $ (\(ArrowMonad am) -> am) . (\r ->
    ArrowMonad (kleislify af r) >>= \x -> ArrowMonad (kleislify (h x) r))

相关return也是ArrowMonad，位于适当的样板层中：

returnY :: ArrowApply y => a -> y r a
returnY x = unkleislify $ \r -> (\(ArrowMonad am) -> am) (return x)

然而，这并不能回答你的问题。要做到这一点，bindY和returnY应与Applicative WrappedArrow实例一致;也就是说，我们应该returnY x = arr (const x)，我们可以使用ap和bindY编写的returnY应该等同于(<*>) WrappedMonad。例如，我们可能会尝试使用相关ArrowMonad实例的定义......

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

...扩展（然后希望简化）returnY：

returnY
unkleislify $ \r -> (\(ArrowMonad am) -> am) (return x)
unkleislify $ \r -> (\(ArrowMonad am) -> am) (ArrowMonad (arr (const x)))
unkleislify $ \r -> arr (const x)
arr (\r -> arr (const x)) &&& arr (const ()) >>> app
arr (const (arr (const x))) &&& arr (const ()) >>> app
arr (\r -> (r, r)) >>> arr (const (arr (const x))) *** arr (const ()) >>> app
arr (\r -> (arr (const x), ())) >>> app

我不知道是否可以将arr (const x)简化为任何ArrowApply。也许能够翻转箭头（如Alec和user2407038建议的那样）将有助于摆脱()，但我还没有解决这个问题。无论如何，对Kleisli至少我们可以继续：

arr (\r -> (arr (const x), ())) >>> app
Kleisli (\r -> return (arr (const x), ())) >>> Kleisli (\(Kleisli f, x) -> f x)
Kleisli ((\r -> return (arr (const x), ())) >=> (\(Kleisli f, x) -> f x))
Kleisli ((\r -> return (Kleisli (return . const x), ()))
    >=> (\(Kleisli f, x) -> f x))
Kleisli (\r -> return (Kleisli (return . const x), ())
    >>= (\(Kleisli f, x) -> f x))
Kleisli (\r -> (\(Kleisli f, x) -> f x) (Kleisli (return . const x), ()))
Kleisli (\r -> (return . const x) ())
Kleisli (\r -> return x)
Kleisli (return . const x)
arr (const x)

我还没有尝试对bindY做同样的事情，但我不知情的猜测是会产生类似的情况。

我们可以为WrappedArrow定义一个Monad实例吗？

2 个答案: