haskell - 什么是单子(monad)？

Question

最近简要地研究了 Haskell，关于 monad 本质上是什么的简短、简洁、实用的解释是什么？

我发现我遇到的大多数解释都相当难以理解并且缺乏实际细节。

Answer 1

第一:术语 monad 如果你不是数学家，这有点空洞。另一个术语是 计算生成器 这更多地描述了它们的实际用途。
它们是链接操作的模式。它看起来有点像面向对象语言中的方法链，但机制略有不同。
该模式主要用于函数式语言(尤其是普遍使用 monad 的 Haskell)，但也可以用于任何支持高阶函数(即可以将其他函数作为参数的函数)的语言。
JavaScript 中的数组支持该模式，因此让我们将其用作第一个示例。
该模式的要点是我们有一个类型(在本例中为 Array)，它具有一个将函数作为参数的方法。提供的操作必须返回相同类型的实例(即返回 Array )。
首先是不使用 monad 模式的方法链接示例:

[1,2,3].map(x => x + 1)

结果是 [2,3,4] .代码不符合 monad 模式，因为我们作为参数提供的函数返回一个数字，而不是一个数组。 monad 形式的相同逻辑是:

[1,2,3].flatMap(x => [x + 1])

这里我们提供了一个返回 Array 的操作。 ，所以现在它符合模式。 flatMap 方法为数组中的每个元素执行提供的函数。它期望一个数组作为每次调用的结果(而不是单个值)，但将结果数组集合合并为一个数组。所以最终结果是一样的，数组 [2,3,4] .
(提供给 map 或 flatMap 之类的方法的函数参数在 JavaScript 中通常称为“回调”。我将其称为“操作”，因为它更通用。)
如果我们链接多个操作(以传统方式):

[1,2,3].map(a => a + 1).filter(b => b != 3)

数组中的结果 [2,4]monad 形式的相同链接:

[1,2,3].flatMap(a => [a + 1]).flatMap(b => b != 3 ? [b] : [])

产生相同的结果，数组 [2,4] .
你会立即注意到 monad 形式比非 monad 更丑!这只是表明 monad 不一定“好”。它们是一种有时有益而有时无益的模式。
请注意，monad 模式可以以不同的方式组合:

[1,2,3].flatMap(a => [a + 1].flatMap(b => b != 3 ? [b] : []))

这里绑定(bind)是嵌套的而不是链接的，但结果是一样的。这是 monad 的一个重要属性，我们将在后面看到。这意味着两个操作组合可以被视为单个操作。
该操作允许返回具有不同元素类型的数组，例如将数字数组转换为字符串数组或其他内容；只要它还是一个数组。
这可以使用 Typescript 符号来更正式地描述。数组的类型为 Array<T> ，其中 T是数组中元素的类型。方法 flatMap()接受类型为 T => Array<U> 的函数参数并返回 Array<U> .
概括地说，monad 是任何类型 Foo<Bar>它有一个“绑定(bind)”方法，它接受类型为 Bar => Foo<Baz> 的函数参数并返回 Foo<Baz> .
这回答了 monad 是什么。这个答案的其余部分将尝试通过示例来解释为什么 monad 在 Haskell 这样的语言中可以成为一种有用的模式，它对它们有很好的支持。
Haskell 和 Do 符号
要将 map /过滤器示例直接转换为 Haskell，我们替换 flatMap与 >>=运算符(operator):

[1,2,3] >>= \a -> [a+1] >>= \b -> if b == 3 then [] else [b] 

>>=运算符是 Haskell 中的绑定(bind)函数。它与 flatMap 的作用相同在 JavaScript 中，当操作数是一个列表时，对于其他类型，它被重载了不同的含义。
但是 Haskell 也有专门用于 monad 表达式的语法， do -block，它完全隐藏了绑定(bind)运算符:

 do a <- [1,2,3] 
    b <- [a+1] 
    if b == 3 then [] else [b] 

这隐藏了“管道”，让您专注于每一步应用的实际操作。
在 do -block，每一行都是一个操作。约束仍然认为块中的所有操作必须返回相同的类型。由于第一个表达式是一个列表，其他操作也必须返回一个列表。
后箭头 <-看起来很像赋值，但请注意，这是在绑定(bind)中传递的参数。因此，当右侧的表达式是一个整数列表时，左侧的变量将是单个整数——但将针对列表中的每个整数执行。
示例:安全导航(Maybe 类型)
关于列表已经足够了，让我们看看 monad 模式如何对其他类型有用。
某些函数可能并不总是返回有效值。在 Haskell 中，这由 Maybe 表示-type，这是一个选项，可以是 Some value或 Nothing .
始终返回有效值的链接操作当然很简单:

streetName = getStreetName (getAddress (getUser 17)) 

但是如果任何函数可以返回 Nothing 呢？ ?我们需要单独检查每个结果，如果不是 Nothing，则只将值传递给下一个函数。 :

case getUser 17 of
      Nothing -> Nothing 
      Just user ->
         case getAddress user of
            Nothing -> Nothing 
            Just address ->
              getStreetName address

相当多的重复检查!想象一下，如果链条更长。 Haskell 使用 Maybe 的 monad 模式解决了这个问题:

do
  user <- getUser 17
  addr <- getAddress user
  getStreetName addr

此 do -block 调用 Maybe 的绑定(bind)函数类型(因为第一个表达式的结果是 Maybe )。如果值为 Just value，则绑定(bind)函数仅执行以下操作, 否则它只是通过 Nothing沿着。
这里使用 monad-pattern 来避免重复代码。这类似于其他一些语言如何使用宏来简化语法，尽管宏以非常不同的方式实现相同的目标。
请注意，是 monad 模式和 Haskell 中对 monad 友好的语法的组合导致代码更清晰。在像 JavaScript 这样对 monad 没有任何特殊语法支持的语言中，我怀疑 monad 模式是否能够在这种情况下简化代码。
可变状态
Haskell 不支持可变状态。所有变量都是常量，所有值都是不可变的。但是 State type 可用于模拟具有可变状态的编程:

add2 :: State Integer Integer
add2 = do
        -- add 1 to state
         x <- get
         put (x + 1)
         -- increment in another way
         modify (+1)
         -- return state
         get


evalState add2 7
=> 9

add2函数构建一个 monad 链，然后以 7 作为初始状态进行评估。
显然，这仅在 Haskell 中才有意义。其他语言支持开箱即用的可变状态。 Haskell 通常“选择加入”语言特性——你在需要时启用可变状态，类型系统确保效果是明确的。 IO 是另一个例子。
IO IO type 用于链接和执行“不纯”函数。
像任何其他实用语言一样，Haskell 有一堆与外部世界交互的内置函数: putStrLine , readLine等等。这些函数被称为“不纯的”，因为它们要么会导致副作用，要么会产生不确定的结果。即使像获取时间这样简单的事情也被认为是不纯的，因为结果是不确定的——用相同的参数调用它两次可能会返回不同的值。
纯函数是确定性的——它的结果完全取决于传递的参数，除了返回一个值之外，它对环境没有任何副作用。
Haskell 非常鼓励使用纯函数——这是该语言的一个主要卖点。不幸的是，对于纯粹主义者来说，您需要一些不纯的函数来做任何有用的事情。 Haskell 的妥协是将纯函数和非纯函数彻底分开，并保证纯函数无法直接或间接执行不纯函数。
这是通过为所有不纯函数提供 IO 来保证的。类型。 Haskell 程序的入口点是 main具有 IO 的函数类型，所以我们可以在顶层执行不纯的函数。
但是语言如何防止纯函数执行不纯函数呢？这是由于 Haskell 的惰性。一个函数只有在它的输出被其他函数消耗时才会被执行。但是没有办法消耗 IO值，除了将其分配给 main .所以如果一个函数想要执行一个不纯的函数，它必须连接到 main并拥有 IO类型。
对 IO 操作使用 monad 链接还可以确保它们以线性和可预测的顺序执行，就像命令式语言中的语句一样。
这将我们带到大多数人会用 Haskell 编写的第一个程序:

main :: IO ()
main = do 
        putStrLn ”Hello World”

do当只有一个操作并因此没有绑定(bind)时，关键字是多余的，但无论如何我都会保留它以保持一致性。 () type 的意思是“空”。这种特殊的返回类型仅对因副作用而调用的 IO 函数有用。
一个更长的例子:

main = do
    putStrLn "What is your name?"
    name <- getLine
    putStrLn "hello" ++ name

这构建了一个 IO 的链操作，并且由于它们被分配给 main函数，它们被执行。
比较 IO与 Maybe显示了 monad 模式的多功能性。对于 Maybe ，该模式用于通过将条件逻辑移动到绑定(bind)函数来避免重复代码。对于 IO ，该模式用于确保 IO的所有操作类型按顺序排列，并且 IO操作不能“泄漏”到纯函数。
总结
在我的主观意见中，monad 模式只有在一种对模式有一些内置支持的语言中才真正值得。否则它只会导致过于复杂的代码。但是 Haskell(和其他一些语言)有一些内置的支持，可以隐藏繁琐的部分，然后该模式可以用于各种有用的事情。像:

避免重复代码 ( Maybe )

添加语言功能，如可变状态或程序分隔区域的异常。

将讨厌的东西与好的东西隔离开 ( IO )

嵌入式领域特定语言 ( Parser )

将 GOTO 添加到语言中。