在最近简要回顾了Haskell之后,对于monad本质上是什么,有什么简单、简洁、实用的解释?

我发现,我遇到的大多数解释都很难理解,而且缺乏实际细节。


当前回答

第一:如果你不是数学家,monad这个词有点空洞。另一个术语是计算构建器,它更能描述它们的实际用途。

它们是链接操作的模式。它看起来有点像面向对象语言中的方法链接,但机制略有不同。

该模式主要用于函数式语言(特别是Haskell,它普遍使用monad),但也可以用于支持高阶函数的任何语言(即可以将其他函数作为参数的函数)。

JavaScript中的数组支持该模式,因此让我们将其作为第一个示例。

模式的要点是我们有一个类型(在本例中为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模式可以以不同的方式组合:

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

这里的绑定是嵌套的,而不是链式的,但结果是一样的。这是单子的一个重要属性,我们稍后会看到。这意味着组合的两个操作可以被视为单个操作。

该操作允许返回具有不同元素类型的数组,例如,将数字数组转换为字符串数组或其他东西;只要它仍然是一个数组。

这可以使用Typescript表示法更正式地描述。数组的类型为array<T>,其中T是数组中元素的类型。flatMap()方法接受类型为T=>Array<U>的函数参数,并返回一个Array<U>。

一般来说,monad是任何类型的Foo<Bar>,它有一个“bind”方法,该方法接受类型为Bar=>Foo<Baz>的函数参数,并返回一个Foo<Baz>。

这回答了单子是什么。这个答案的其余部分将试图通过示例来解释为什么monads在Haskell这样的语言中是一种有用的模式,而Haskell对monads有很好的支持。

Haskell和Do表示法

要将map/filter示例直接转换为Haskell,我们将flatMap替换为>>=运算符:

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

>>=运算符是Haskell中的绑定函数。当操作数是一个列表时,它与JavaScript中的flatMap相同,但对于其他类型,它被重载了不同的含义。

但是Haskell还为monad表达式提供了专用语法do块,它完全隐藏了绑定运算符:

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

这将隐藏“管道”,并让您专注于在每个步骤中应用的实际操作。

在do块中,每一行都是一个操作。约束仍然认为块中的所有操作都必须返回相同的类型。因为第一个表达式是一个列表,所以其他操作也必须返回一个列表。

向后箭头<-看起来像赋值,但请注意,这是绑定中传递的参数。因此,当右侧的表达式是整数列表时,左侧的变量将是一个整数,但将对列表中的每个整数执行。

示例:安全导航(Maybe类型)

关于列表,让我们来看看monad模式如何对其他类型有用。

某些函数可能不总是返回有效值。在Haskell中,这由Maybe类型表示,该类型是Just 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块调用Maybe类型的绑定函数(因为第一个表达式的结果是Maybe)。绑定函数仅在值为Just值时执行以下操作,否则只传递Nothing。

这里使用monad模式来避免重复代码。这与其他一些语言使用宏来简化语法的方式类似,尽管宏以非常不同的方式实现了相同的目标。

请注意,Haskell中monad模式和monad友好语法的结合导致了代码更干净。在JavaScript这样的语言中,如果没有对monad的任何特殊语法支持,我怀疑monad模式是否能够在这种情况下简化代码。

可变状态

Haskell不支持可变状态。所有变量都是常量,所有值都是不可变的。但State类型可用于模拟具有可变状态的编程:

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类型用于链接和执行“不纯”函数。

与任何其他实用语言一样,Haskell有一系列与外界接口的内置函数:putStrLine、readLine等。这些函数被称为“不纯”,因为它们要么会产生副作用,要么会产生不确定性的结果。即使是像获取时间这样简单的事情也被认为是不纯洁的,因为结果是不确定的——用相同的参数调用两次可能会返回不同的值。

纯函数是确定性的——它的结果完全取决于传递的参数,除了返回值之外,它对环境没有任何副作用。

Haskell大力鼓励使用纯函数——这是该语言的一个主要卖点。不幸的是,对于纯粹主义者来说,你需要一些不纯的函数来做任何有用的事情。Haskell折衷方案是将纯函数和不纯函数彻底分开,并保证纯函数无法直接或间接执行不纯函数。

这是通过给所有不纯函数赋予IO类型来保证的。Haskell程序的入口点是具有IO类型的主函数,因此我们可以在顶层执行不纯的函数。

但是该语言如何防止纯函数执行不纯函数?这是因为Haskell的懒惰本性。只有当某个函数的输出被其他函数消耗时,才执行该函数。但除了将IO值分配给main之外,没有办法使用它。因此,如果一个函数想要执行一个不纯的函数,它必须连接到main并具有IO类型。

对IO操作使用monad链接还可以确保它们以线性和可预测的顺序执行,就像命令式语言中的语句一样。

这让我们看到大多数人会用Haskell编写的第一个程序:

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

当只有一个操作,因此没有什么要绑定时,do关键字是多余的,但为了保持一致性,我还是保留了它。

()类型表示“无效”。这种特殊的返回类型仅适用于因其副作用而调用的IO函数。

更长的示例:

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

这构建了一个IO操作链,因为它们被分配给主功能,所以它们被执行。

将IO与Maybe进行比较表明了monad模式的多功能性。对于Maybe,该模式用于通过将条件逻辑移动到绑定函数来避免重复代码。对于IO,该模式用于确保IO类型的所有操作都是有序的,并且IO操作不会“泄漏”到纯函数。

总结

在我的主观看法中,monad模式只有在对该模式有一些内置支持的语言中才真正有价值。否则,它只会导致过于复杂的代码。但是Haskell(和其他一些语言)有一些内置支持,隐藏了繁琐的部分,然后该模式可以用于各种有用的事情。喜欢:

避免重复代码(可能)为程序的分隔区域添加可变状态或异常等语言特性。将讨厌的东西与美好的东西隔离开来(IO)嵌入式域特定语言(解析器)将GOTO添加到语言中。

其他回答

公主对F#计算表达式的解释帮助了我,尽管我仍然不能说我真的理解了。

编辑:这个系列-用javascript解释monad-对我来说是一个“打破平衡”的系列。

http://blog.jcoglan.com/2011/03/05/translation-from-haskell-to-javascript-of-selected-portions-of-the-best-introduction-to-monads-ive-ever-read/http://blog.jcoglan.com/2011/03/06/monad-syntax-for-javascript/http://blog.jcoglan.com/2011/03/11/promises-are-the-monad-of-asynchronous-programming/

我认为理解单子是一件让你毛骨悚然的事。从这个意义上说,尽可能多地阅读“教程”是一个好主意,但通常奇怪的东西(不熟悉的语言或语法)会让你的大脑无法专注于基本内容。

有些事情我很难理解:

基于规则的解释对我来说从未奏效,因为大多数实际示例实际上需要的不仅仅是返回/绑定。此外,称之为规则也无济于事。这更像是“有些东西有共同点,我们把它们称为‘单子’,把共同点称为‘规则’”。Return(a->M<a>)和Bind(M<a>->(a->M<b>)->M<b>)很好,但我永远无法理解Bind如何从M<a>中提取a,以便将其传递给a->M<b>。我不认为我在任何地方读过(也许这对其他人来说都很明显),Return(M<a>->a)的反面必须存在于monad内部,它只是不需要暴露。

如果你要求对如此抽象的东西做出简洁、实用的解释,那么你只能希望得到一个抽象的答案:

a -> b

是表示从as到bs的计算的一种方式。您可以将计算链接起来,也可以将它们组合在一起:

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

更复杂的计算需要更复杂的类型,例如:

a -> f b

是从as到bs到fs的计算类型。您还可以编写它们:

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

事实证明,这种模式无处不在,并且与上面的第一个组合具有相同的财产(结合性、右-和左-同一性)。

人们必须给这个模式起一个名字,但如果知道第一个组合被正式描述为半群体,这会有帮助吗?

“单子和圆括号一样有趣和重要”(奥列格·基斯廖夫)

对于来自命令式背景(c#)的人,

考虑以下代码

bool ReturnTrueorFalse(SomeObject input)
{
    if(input.Property1 is invalid)
    {
        return false;
    }

    if(input.Property2 is invalid)
    {
        return false;
    }

    DoSomething();
    return true;
}

您会看到很多这样的代码,甚至不会看到早期返回,但所有检查都是嵌套完成的。现在,Monad是一种模式,它可以像下面一样被压平

Monad<bool> ReturnTrueorFalse(SomeObject input) =>
    from isProperty1Valid in input.Property1
    from isProperty2Valid in input.Property2
    select Monad.Create(isProperty1Valid && isProperty2Valid);

这里有几点需要注意。首先,更改函数的返回值。其次,输入的两个财产都必须是Monad。接下来,Monad应该实现SelectMany(LINQ的展平运算符)。由于SelectMany是为该类型实现的,因此可以使用查询语法编写语句

那幺,什么是莫纳德?它是一种以可组合方式对返回相同类型的表达式进行扁平化的结构。这在函数式编程中特别有用,因为大多数函数式应用程序倾向于将状态和IO保持在应用程序的边缘层(例如:控制器),并在整个调用堆栈中返回基于Monad的返回值,直到需要解包该值。当我第一次看到这张照片时,我最大的优点是它很容易在眼睛上看到,也很有陈腔滥调。

每个c#(现在几乎每个人)开发人员都能立即识别的Monad的最佳示例是async/await。在.Net4.5之前,我们必须使用ContinueWith编写基于任务的语句来处理回调,在async/await之后,我们开始使用同步语法来处理异步语法。这是可能的,因为Task是一个“monad”。

关于OOP开发人员的详细说明,请参阅本文,这是一个简单的实现和语言文本,其中包含许多很棒的Monad和大量关于函数式编程的信息

解释monad似乎就像解释控制流语句一样。想象一下,一个非程序员要求你解释它们?

你可以给他们一个涉及理论的解释——布尔逻辑、寄存器值、指针、堆栈和框架。但那太疯狂了。

你可以用语法来解释它们。基本上,C中的所有控制流语句都有大括号,您可以通过它们相对于括号的位置来区分条件和条件代码。这可能更疯狂。

或者,您也可以解释循环、if语句、例程、子例程以及可能的协例程。

Monad可以取代相当多的编程技术。语言中有一种特定的语法支持它们,还有一些关于它们的理论。

它们也是函数式程序员使用命令式代码而不承认它的一种方式,但这并不是他们唯一的用途。

世界需要的是另一篇monad博客文章,但我认为这对识别野外现存的monad很有用。

单子是分形

上面是一个叫做Sierpinski三角形的分形,这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构,其中部分与整体相似(在这种情况下,正好是母三角形比例的一半)。单子是分形。给定一个一元数据结构,它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用,这也是为什么它在许多情况下都会出现。