为什么“let”语句强制“applicative do”块需要monad约束？

Question

考虑这个例子：

{-# language ApplicativeDo #-}

module X where

data Tuple a b = Tuple a b deriving Show

instance Functor (Tuple a) where
    fmap f (Tuple x y) = Tuple x (f y)

instance Foldable (Tuple a) where
    foldr f z (Tuple _ y) = f y z

instance Traversable (Tuple a) where
    traverse f (Tuple x y) = do
        y' <- f y
        let t' = Tuple x y'
        return $ t'

看起来不错！但是没有：

[1 of 1] Compiling X                ( X.hs, interpreted )

X.hs:15:9: error:
    • Could not deduce (Monad f) arising from a do statement
      from the context: Applicative f
        bound by the type signature for:
                   traverse :: forall (f :: * -> *) a1 b.
                               Applicative f =>
                               (a1 -> f b) -> Tuple a a1 -> f (Tuple a b)
        at X.hs:14:5-12
      Possible fix:
        add (Monad f) to the context of
          the type signature for:
            traverse :: forall (f :: * -> *) a1 b.
                        Applicative f =>
                        (a1 -> f b) -> Tuple a a1 -> f (Tuple a b)
    • In a stmt of a 'do' block: y' <- f y
      In the expression:
        do y' <- f y
           let t' = Tuple x y'
           return $ t'
      In an equation for ‘traverse’:
          traverse f (Tuple x y)
            = do y' <- f y
                 let t' = ...
                 return $ t'
   |
15 |         y' <- f y
   |         ^^^^^^^^^
Failed, no modules loaded.

即使这样也失败了：

instance Traversable (Tuple a) where
    traverse f (Tuple x y) = do
        y' <- f y
        let unrelated = 1
        return $ Tuple x y'

因此，引入任何let 语句都会从“applicative do” 中删除“applicative”。为什么？

Answer 1

它会翻译成

let unrelated = 1 in return $ Tuple x y'

没有return <something>的形式，而applicative做requires the last statement to be a return or pure：

一般来说，do 语句引发Monad 约束的规则如下。如果 do 表达式具有以下形式：

do p1 <- E1; ...; pn <- En; return E

如果p1...pn 定义的变量都没有在E1...En 中提及，并且p1...pn 都是变量或惰性模式，那么表达式将只需要Applicative。否则，表达式将需要Monad。该块可能会返回一个纯表达式E，具体取决于结果p1...pn 与return 或pure。

注意：最后的语句必须完全匹配这些模式之一：

return E
return $ E
pure E
pure $ E

否则 GHC 无法将其识别为 return 语句，并且我们在上面看到的使用 <$> 的转换不适用。特别是，return . Just $ x 或 let x = e in return x 等细微变化将无法识别。

如果你看https://gitlab.haskell.org/ghc/ghc/wikis/applicative-do中关于脱糖的描述，它也不支持let。

Answer 2

你想让这个去糖的应用表达式是什么？ monadic 表达式是一系列链式作用域，因此 let 引入一个扩展到所有剩余作用域的绑定是有意义的，但对于 applicative，各种表达式不能真正相互依赖，因此没有作用域将let 脱糖是有意义的。