【问题标题】:Why use such a peculiar function type in monads?为什么在 monad 中使用这种特殊的函数类型?
【发布时间】:2014-05-27 22:09:48
【问题描述】:

Haskell 的新手,我想弄清楚这个 Monad 的东西。一元绑定运算符 -- >>= -- 有一个非常奇特的类型签名:

(>>=) :: Monad m => m a -> (a -> m b) -> m b

为了简化,让我们用Maybe 代替m:

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

但是,请注意,定义可以以三种不同的方式编写:

(>>=) :: Maybe a -> (Maybe a -> Maybe b) -> Maybe b
(>>=) :: Maybe a -> (      a -> Maybe b) -> Maybe b
(>>=) :: Maybe a -> (      a ->       b) -> Maybe b

在这三个中,中间的那个是最不对称的。但是,我知道如果我们想避免第一个是没有意义的(LYAH 称之为样板代码)。但是,在接下来的两个中,我更喜欢最后一个。对于Maybe,这看起来像:

当这被定义为:

(>>=) :: Maybe a -> (a -> b) -> Maybe b

instance Monad Maybe where
   Nothing  >>= f = Nothing
   (Just x) >>= f = return $ f x

这里,a -> b 是一个普通函数。另外,我没有立即看到任何不安全的东西,因为Nothing 在函数应用程序之前 捕获了异常,因此除非获得Just a,否则不会调用a -> b 函数。

所以也许有一些对我来说并不明显的东西导致(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b 定义比更简单的(>>=) :: Maybe a -> (a -> b) -> Maybe b 定义更受欢迎? (我认为是一个)更简单的定义是否存在一些固有问题?

【问题讨论】:

  • 当你说 bind 的定义可能有不同的写法时,你可能是不正确的;注意f :: Maybe a -> (Maybe a -> Maybe b) -> Maybe b == flip ($); and g :: Maybe a -> ( a -> b) -> Maybe b == flip fmap. So the other functions you listed are both useful and both exist, they just live in a place other than Monad`。
  • Maybe a -> (a -> b) -> Maybe b 不允许您绑定返回 Maybe b 的函数。您将无法在计算进行到一半时获得Nothing。
  • 另一种可能性是Maybe a -> Maybe (a -> b) -> Maybe b——基本上是<*> 来自Applicative(一种“介于”Functor 和 Monad 之间)。

标签: haskell types monads typeclass


【解决方案1】:

如果您考虑以下派生函数(来自Control.Monad),它会更加对称:

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
(f >=> g) x = f x >>= g

这个函数很重要的原因是它遵循三个有用的方程:

-- Associativity
(f >=> g) >=> h = f >=> (g >=> h)

-- Left identity
return >=> f = f

-- Right identity
f >=> return = f

这些是category laws,如果你将它们翻译成使用(>>=)而不是(>=>),你会得到三个单子定律:

(m >>= g) >>= h = m >>= \x -> (g x >>= h)

return x >>= f = f x

m >>= return = m

因此,实际上不是 (>>=) 是优雅的运算符,而是 (>=>) 是您正在寻找的对称运算符。然而,我们通常认为(>>=) 的原因是因为这就是do 符号去糖的原因。

【讨论】:

  • 感谢您的回答。我想我有点明白你在说什么。在我完全理解你在说什么之前,我可能必须通过这个并解决一堆例子,但我非常感谢你的回复。
【解决方案2】:

让我们考虑Maybe monad 的常见用途之一:处理错误。假设我想安全地划分两个数字。我可以写这个函数:

safeDiv :: Int -> Int -> Maybe Int
safeDiv _ 0 = Nothing
safeDiv n d = n `div` d

然后使用标准的Maybe monad,我可以这样做:

foo :: Int -> Int -> Maybe Int
foo a b = do
  c <- safeDiv 1000 b
  d <- safeDiv a c  -- These last two lines could be combined.
  return d          -- I am not doing so for clarity.

请注意,在每一步,safeDiv 都可能失败,但在这两个步骤中,safeDiv 都采用 Ints,而不是 Maybe Ints。如果&gt;&gt;= 有这个签名:

(>>=) :: Maybe a -> (a -> b) -> Maybe b

您可以将函数组合在一起,然后给它一个Nothing 或Just,或者它会解开Just,遍历整个管道,然后在Just 中重新包装它,或者它只会通过Nothing 基本上不受影响。这可能有用,但它不是单子。为了让它有任何用处,我们必须能够在中间失败,这就是这个签名给我们的:

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b

顺便说一句,你设计的签名确实存在:

flip fmap :: Maybe a -> (a -> b) -> Maybe b

【讨论】:

  • +1。事实上,fmap :: (Functor f) =&gt; (a -&gt; b) -&gt; f a -&gt; f b 非常有用,但在上面解释的意义上,严格来说不如 (&gt;&gt;=) 强大。
  • +1 我发现我正在查看的定义已经是 Functor?那是对的吗?在这种情况下,我将不得不查找 Functor 和 Monad 之间的差异,以及为什么 Monad 更好。我不能立即理解所有内容,但现在我知道在哪里看。感谢您的回答。
  • @ssm:Monad 并没有更好,你可以用它们做更多的事情(无论如何)。所有的 Monad 都是 Functor,所以 Monad 是一个带有一些额外内容的 Functor。 Applicative 也是如此。事实上,所有的 Monad 都是 Applicative,所有的 Applicative 都是 Functor。
【解决方案3】:

a -&gt; Maybe b 越复杂的函数越通用,也更有用,可以用来实现简单的函数。反过来也行不通。

您可以从函数f :: a -&gt; b 构建a -&gt; Maybe b 函数:

f' :: a -> Maybe b
f' x = Just (f x)

或者,就return而言(对于Maybe,它是Just):

f' = return . f

反过来不一定是可能的。如果您有一个函数g :: a -&gt; Maybe b 并希望将它与“简单”绑定一起使用,则必须首先将其转换为函数a -&gt; b。但这通常不起作用,因为g 可能会返回Nothing,而a -&gt; b 函数需要返回b 值。

所以通常“简单”绑定可以根据“复杂”绑定来实现,但不能反过来。此外,复杂的绑定通常很有用,没有它会使许多事情变得不可能。所以通过使用更通用的绑定 monads 适用于更多的情况。

【讨论】:

    【解决方案4】:

    (&gt;&gt;=) 的替代类型签名的问题在于,它只是意外地适用于 Maybe monad,如果你用另一个 monad(即 List monad)尝试它,你会看到它在 @ 的类型上崩溃一般情况下为 987654322@。您提供的签名没有描述单子绑定,单子定律不能不符合该定义。

    import Prelude hiding (Monad, return)
    
    -- assume monad was defined like this
    class Monad m where
      (>>=)  :: m a -> (a -> b) -> m b
      return :: a -> m a
    
    instance Monad Maybe where
      Nothing  >>= f = Nothing
      (Just x) >>= f = return $ f x
    
    instance Monad [] where
      m >>= f   =  concat (map f m)
      return x  =  [x]
    

    因类型错误而失败:

        Couldn't match type `b' with `[b]'
          `b' is a rigid type variable bound by
              the type signature for >>= :: [a] -> (a -> b) -> [b]
              at monadfail.hs:12:3
        Expected type: a -> [b]
          Actual type: a -> b
        In the first argument of `map', namely `f'
        In the first argument of `concat', namely `(map f m)'
        In the expression: concat (map f m)
    

    【讨论】:

    • 简单的m &gt;&gt;= f = map f m怎么样?
    • @ssm:这是一个很好的证明,您提出的&gt;&gt;= 的类型签名在功能上与Functor 完全相同(Monad 因为它的存在比@ 更强大987654329@).
    • 这正是 fmap 的 Functor 定义,而不是 monad。
    • @ssm,你可能会发现在Functor 之后和Monad 之前查看Applicative 类型类会很有帮助。 Applicative 函子有点弱 Monad 可能会帮助您了解 Monad 的动机
    • 此外,缺少的“步骤”几乎定义了您想到的函数 (fmap) 和 &gt;&gt;= 之间的区别是一个函数 join :: (Monad m) =&gt; m (m a) -&gt; m a 其中m &gt;&gt;= f 相当于join (fmap f m)。因此,当您重新访问 Monad 并希望了解 bind 提供的功能优于 fmap 时,分析 join 在某些示例中的作用可能会给您一些见解。如果这太令人困惑,您可以暂时忽略它。
    【解决方案5】:

    使 monad 成为 monad 的原因在于“join”是如何工作的。回想一下 join 的类型:

    join :: m (m a) -> m a
    

    'join' 所做的是“解释”一个 monad 动作,它根据 monad 动作返回一个 monad 动作。所以,你可以认为它剥离了一层单子(或者更好的是,将内层的东西拉到外层)。这意味着“m”形成一个“堆栈”,在“调用堆栈”的意义上。每个“m”代表一个上下文,“join”让我们按顺序将上下文连接在一起。

    那么,这与绑定有什么关系?回忆:

    (>>=) :: m a -> (a -> m b) -> m b
    

    现在考虑 f :: a -> m b 和 ma :: m a:

    fmap f ma :: m (m b)
    

    也就是说,将f直接应用于ma中的a的结果是an(m(m b))。我们可以对此应用join,以获得m b。总之,

    ma >>= f = join (fmap f ma)
    

    【讨论】:

      猜你喜欢
      • 2015-05-23
      • 2013-04-13
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2011-10-31
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多