4赞

当前位置: 开发笔记 > 编程语言 > 正文

什么是monad？

作者：wangtao | 2023-09-05 19:43

如何解决《什么是monad？》经验，为你挑选了26个好方法。

最近简要介绍了Haskell,对于monad本质上是什么,简单,简洁,实用的解释是什么？

我发现我遇到的大多数解释都是相当难以接近的,缺乏实际细节.

1> JacquesB..：

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

你问一些实际的例子:

示例1:列表理解:

[x*2 | x<-[1..10], odd x]

此表达式返回1到10范围内所有奇数的双精度数.非常有用!

事实证明,这实际上只是List monad中某些操作的语法糖.相同的列表理解可以写成:

do
   x <- [1..10]
   guard (odd x)
   return (x * 2)

甚至:

[1..10] >>= (\x -> guard (odd x) >> return (x*2))

示例2:输入/输出:

do
   putStrLn "What is your name?"
   name <- getLine
   putStrLn ("Welcome, " ++ name ++ "!")

两个示例都使用monad,AKA计算构建器.共同的主题是monad 链以一些特定的,有用的方式运作.在列表推导中,操作被链接,使得如果操作返回列表,则对列表中的每个项执行以下操作.另一方面,IO monad按顺序执行操作,但传递"隐藏变量",表示"世界状态",这允许我们以纯函数方式编写I/O代码.

事实证明链接操作的模式非常有用,并且在Haskell中用于许多不同的事情.

另一个例子是例外:使用Errormonad,操作被链接,使得它们按顺序执行,除非抛出错误,在这种情况下,链的其余部分被放弃.

list-comprehension语法和do-notation都是使用>>=运算符链接操作的语法糖.monad基本上只是一种支持>>=运营商的类型.

示例3:解析器

这是一个非常简单的解析器,它解析带引号的字符串或数字:

parseExpr = parseString <|> parseNumber

parseString = do
        char '"'
        x <- many (noneOf "\"")
        char '"'
        return (StringValue x)

parseNumber = do
    num <- many1 digit
    return (NumberValue (read num))

这些操作char,digit等等都非常简单.它们匹配或不匹配.神奇的是管理控制流程的monad:操作按顺序执行,直到匹配失败,在这种情况下,monad回溯到最新状态<|>并尝试下一个选项.同样,一种使用一些额外的,有用的语义来链接操作的方法.

例4:异步编程

上面的例子在Haskell中,但事实证明F#也支持monad.这个例子是从Don Syme偷来的:

let AsyncHttp(url:string) =
    async {  let req = WebRequest.Create(url)
             let! rsp = req.GetResponseAsync()
             use stream = rsp.GetResponseStream()
             use reader = new System.IO.StreamReader(stream)
             return reader.ReadToEnd() }

此方法获取网页.妙语是使用GetResponseAsync- 它实际上等待单独线程上的响应,而主线程从函数返回.当收到响应时,最后三行在生成的线程上执行.

在大多数其他语言中,您必须为处理响应的行显式创建单独的函数.该async单子能够"分裂"自身块和推迟后半期的执行.(async {}语法表示块中的控制流由asyncmonad 定义.)

他们如何工作

那么monad怎么能做所有这些奇特的控制流程呢？在do-block(或在F#中调用的计算表达式)中实际发生的是每个操作(基本上每一行)都包含在一个单独的匿名函数中.然后使用bind运算符(>>=在Haskell中拼写)组合这些函数.由于bind操作组合了函数,它可以按照它认为合适的方式执行它们:顺序,多次,反向,丢弃一些,在感觉到它时在单独的线程上执行一些等等.

例如,这是示例2中IO代码的扩展版本:

putStrLn "What is your name?"
>>= (\_ -> getLine)
>>= (\name -> putStrLn ("Welcome, " ++ name ++ "!"))

这是更加丑陋的,但实际发生的事情也更加明显.该>>=操作是神奇的成分:它需要一个值(左侧)和具有功能(右侧)相结合的,以产生新的价值.然后,下一个>>=运算符将获取该新值,并再次与函数组合以生成新值.>>=可以被视为一个迷你评估者.

请注意,>>=对于不同的类型会重载,因此每个monad都有自己的实现>>=.(链中的所有操作都必须是同一个monad的类型,否则>>=操作符将无法工作.)

最简单的实现>>=只是获取左边的值并将其应用于右边的函数并返回结果,但如前所述,使整个模式有用的是当monad的实现中有一些额外的事情发生时>>=.

值如何从一个操作传递到下一个操作还有一些额外的聪明,但这需要对Haskell类型系统进行更深入的解释.

加起来

在Haskell术语中,monad是一个参数化类型,它是Monad类型的一个实例,它>>=与一些其他运算符一起定义.在外行人看来,monad只是一种>>=定义操作的类型.

本身>>=只是链接函数的一种繁琐的方式,但是由于存在隐藏"管道"的记号,monadic操作变成了一个非常好的和有用的抽象,在语言的许多地方很有用,并且很有用用语言创建自己的迷你语言.

为什么单子难？

对于许多Haskell学习者来说,monad是他们像砖墙一样的障碍.并不是monad本身很复杂,而是实现依赖于许多其他高级Haskell功能,如参数化类型,类型类等.问题是Haskell I/O基于monad,I/O可能是你在学习新语言时想要理解的第一件事 - 毕竟,创建不生成任何语言的程序并不是很有趣输出.我没有立即解决这个鸡和蛋的问题,除非像对待"魔法发生在这里"之类的I/O,直到你有足够的语言其他部分经验.抱歉.

关于monad的优秀博客:http: //adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

我读了所有这些并且仍然不知道monad是什么,除了Haskell程序员不能很好地解释这个事实.这些例子并没有多大帮助,因为这些都是没有monad可以做的事情,而这个答案并没有说清楚monad如何使它们变得更容易,只会更加混乱.这个答案中接近有用的部分是删除了例子#2的句法糖.我说接近,因为除了第一行之外,扩展与原始版本没有任何真正的相似之处.

解释monad似乎特有的另一个问题是它是用Haskell编写的.我不是说Haskell是一种糟糕的语言 - 我说这对于解释monad是一种糟糕的语言.如果我知道Haskell我已经理解了monad,那么如果你想解释monad,那么首先要使用一种不懂monad的人更容易理解的语言.如果您必须*使用Haskell,请不要使用语法糖 - 使用您可以使用的最小,最简单的语言子集,并且不要假设您了解Haskell IO.

另外,我不同意你关于为什么monad很难的结论.如果monad本身并不复杂,那么你应该能够在没有一堆行李的情况下解释它们是什么.当我问"什么是monad"这个问题时,我不想知道实现情况,我想知道它的意思是什么.到目前为止似乎答案是"因为haskell的作者是sadomasochists并决定你应该做一些愚蠢的事情来完成简单的事情,所以你必须学习使用haskell的monads,而不是因为它们在任何方面都有用他们自己"...

但是......那不可能是对的,可以吗？我认为单子很难,因为没有人能够弄清楚如何解释它们而不会陷入令人困惑的实施细节.我的意思是......什么是校车？它是一个金属平台,前面有一个装置,它消耗一种精炼的石油产品,在一个循环中驱动一些金属活塞,这些金属活塞又转动一个曲轴连接到一些驱动一些轮子的齿轮上.轮子周围有橡胶袋,与橡胶沥青表面相接,使座椅向前移动.座位前进是因为......

作为一个在理解monad时遇到很多问题的人,我可以说这个答案有点帮助.但是,还有一些我不理解的事情.列表理解以monad的形式出现在什么方面？那个例子有扩展形式吗？关于大多数monad解释的另一件事真的困扰我,包括这个 - 是他们继续混淆"什么是monad？" 与"什么是monad有益？" 和"monad如何实现？".当你写"Monad基本上只是一种支持>> =运算符的类型时,你跳过那条鲨鱼." 哪个让我...

@LaurenceGonsalves我同意查理在这里."Monad"主要指的是用于以纯粹功能的方式构造复杂行为的界面模式.Monads的存在更多是为了方便而不是必需.Maybe monad就是一个很好的例子.这不是必需的.您可以在代码中将if-then-else语句的长序列链接在一起,但是谁想要这样做呢？因此,不使用普通的函数组合运算符,而是使用'重载'函数组合运算符,它自动插入if-then-else的东西.这个运算符是>> =.

Monads来自范畴理论,数学家喜欢将其称为"一般抽象无意义".他们的意思是赞美.

抓我的头.这似乎是一个实现细节,它并没有真正帮助我回答"我为什么要使用monad"这个问题.这可能是真的,但直到那时的解释并没有为我做好准备.我并没有考虑"为什么这是一个棘手的问题的确,为什么,我会需要的是某种类型的支撑>> =运算符.嘿,原来这是一个单子是什么!" 不,这不是我的脑袋,因为我不知道什么是>>运算符,或者什么是有益的,我也没有遇到它解决的问题.

..."这个匿名函数*加入*那个*,*加入*另一个".另外,在代码中完全不同的地方,您可以定义"加入"的含义.在步行XML以查找Quantity属性的示例中,"join to"将被定义为"如果前一个匿名函数找到了它希望找到的XML节点,则继续执行下一个匿名函数.否则,停止评估所有匿名函数和报告错误." 所以...我认为这解释了......

完成了一个完全致力于函数式编程的荣誉级大学课程,并被我的讲师宣布为"高级Haskell程序员"......我仍然觉得我只是模糊地知道monads**是什么**.我认为问题在于monad是非常抽象的概念(这使得它们如此有用).我非常了解*个人*monad(list,IO,Maybe,Cont,ST等); 什么是难以捉摸的是这个叫monad**的东西是**以某种方式统一所有这些概念.

(事情只是"代码片段"),并表示这些事物是"联合在一起"的,而不必在任何地方重复"联合在一起"在具体案例中的含义.例如,假设您正在处理XML,并且需要到第三个Transaction元素,到第四个LineItem元素,并读取其Quantity属性.很简单.你甚至可以编写一个XPATH来实现它.但是,由于这些项目中的每一项都可能完全丢失,这使事情变得更加复杂.那么,是否还有第三个Transaction元素？如果doc只有2个Transaction元素怎么办...

...为了你.在这种情况下,Haskell可以解决问题.为什么？因为Haskell非常善于处理匿名函数.如果给Haskell一个匿名函数列表,它可以携带该列表并在以后执行这些函数,并使用不同的参数等.因此,Haskell可以允许您编写"路径行走"代码以获取Quantity属性*没有*乱丢它与错误检查代码.您可以将路径行走代码编写为匿名函数列表,并使用语法,...

@CharlieFlowers对不起,不,这没有帮助.你说monads使事情变得更容易"表达和维护"而没有任何证据支持这一点.相反,我看到很多人不理解它们,还有成堆无益的教程,这些教程表明即使是所谓的"开悟"也不能理解monad足以解释它们.你与DSL的比较也让我想知道你是在谈论的是do-notation而不是monad.在了解糖之前,我想了解实际的monad.

......还是根本没有？如果它有3个Transaction元素,但第3个Transaction元素没有第4个LineItem元素怎么办？最后,如果有第4个LineItem元素,但该元素没有Quantity属性,该怎么办？这会成为一种痛苦,因为你的代码将路径转移到你关心的Quantity属性,并且用一大堆错误检查代码来"处理",以处理文档中缺少所需项目的情况.Haskell希望成为一种强大的编程语言,解决这些棘手的表现力问题......

麻烦的是,你不能给出一个明确的具体例子.因为如果你尝试......它只是List,或者Maybe或IO.哪些都容易掌握,但不一定能帮助未开悟的人看到整个单子.我想这就是为什么他们很难; 它们确实足够简单(例如,你需要记住以正确实现和使用monad的数量远远小于你在Java中使用类所需要知道的数量).但monad的统一概念非常抽象.

布列塔尼和@musicfreak,他*解释了monad是什么以及它是如何工作的...但由于某种原因你无法遵循它.我想帮忙,但我已经知道太多了,因为我在学习曲线上有点(只是一点点)领先于你.如果我们能够共同努力找到差距,我很乐意帮助关闭它.如果您已经学会了答案,那么请告诉我.让我回答一个问题,这个问题可能是差距的一部分 - "为什么除了Haskell的其余部分我们还需要monad？" 我们需要monad因为我们希望能够写出一系列"东西"......

为什么monads存在于Haskell中,为什么你想要使用它们,以及它们如何工作的一部分(最重要的部分).如果你把它与JacquesB的优秀答案结合在一起,我们会到达某个地方吗？你的下一个问题是什么？

我完全同意@Breton.你给出了很好的例子,说明了什么类型的代码使用monad,但是你失败了,IMO,解释*monad是*和*它是如何工作的*,这是重要的.

当然,你稍后会补偿它,但我恐怕仍然不知道"什么是monad"这个问题的答案,更不用说简单的简洁解释了.

@LaurenceGonsalves我现在只有时间说一件事,但我希望它会有所帮助.你说你可以在没有monad的情况下做到这一切.是的,你可以.monad与dsl类似,因为你可以不用dsl.但它们很好,因为它们可以更容易地表达和维护您想要表达的内容.

@George你刚刚描述了`Maybe` monad.其他人做不同的事情.解释monad的问题在于,每一个都是非常明显的,但它们具有共同结构的事实起初可能是反直觉的.

伙计们，单子来自数学界。如果您想知道“什么是单子”，则必须与数学家交谈。仅仅因为它是某些编程语言，并不意味着程序员应该解释它的含义。例如，编程语言可以对数字求和，但是如果您想对*什么是*进行解释，则必须与数学家交谈。我希望现在已经清楚了。我的程序员同伴，不要再试图解释单子了。

2> Mathematical..：

解释"什么是monad"有点像说"什么是数字？" 我们一直使用数字.但想象你遇到了一个对数字一无所知的人.如何赫克你能解释的数字是什么？你怎么会开始描述为什么这可能有用呢？

什么是monad？简短的回答:这是一种将操作链接在一起的特定方式.

实质上,您正在编写执行步骤并使用"绑定功能"将它们链接在一起.(在Haskell中,它被命名>>=.)您可以自己编写对bind操作符的调用,或者您可以使用语法sugar,使编译器为您插入这些函数调用.但无论哪种方式,每个步骤都通过调用此绑定函数来分隔.

所以bind函数就像一个分号; 它分离了一个过程中的步骤.绑定功能的作用是获取上一步的输出,并将其输入下一步.

这听起来不太难,对吧？但是不止一种单子.为什么？怎么样？

好吧,绑定功能可以从一步获取结果,并将其提供给下一步.但是,如果这是"所有"monad所做的......那实际上并不是非常有用.这一点很重要:每个有用的 monad 除了成为monad 之外还会做其他事情.每一个有用的单子都有"特殊的力量",这使它独一无二.

(没有什么特别之处的monad 被称为"身份monad".与身份功能相似,这听起来像一个完全没有意义的事情,但结果却不是......但那是另一个故事™.)

基本上,每个monad都有自己的bind函数实现.您可以编写一个绑定函数,以便在执行步骤之间进行连接.例如:

如果每个步骤都返回一个成功/失败指示符,则只有在前一个步骤成功的情况下,才能让绑定执行下一步.这样,失败的步骤会"自动"中止整个序列,而不需要您进行任何条件测试.(The Failure Monad.)

扩展这个想法,你可以实现"例外".(错误Monad或Exception Monad.)因为您自己定义它们而不是语言功能,所以您可以定义它们的工作方式.(例如,您可能希望忽略前两个异常,并且仅在抛出第三个异常时中止.)

您可以使每个步骤返回多个结果,并使绑定函数循环遍历它们,将每个步骤提供给下一步.这样,在处理多个结果时,您不必在整个地方继续编写循环.绑定功能"自动"为您完成所有这些.(名单Monad.)

除了将"结果"从一个步骤传递到另一个步骤之外,您还可以让bind函数传递额外的数据.此数据现在不会显示在您的源代码中,但您仍然可以从任何地方访问它,而无需手动将其传递给每个函数.(读者Monad.)

您可以将其设置为可以替换"额外数据".这允许您模拟破坏性更新,而无需实际进行破坏性更新.(国家莫纳德及其堂兄作家莫纳德.)

因为您只是在模拟破坏性更新,所以您可以通过真正的破坏性更新轻松完成这些操作.例如,您可以撤消上次更新,或恢复为旧版本.

您可以创建一个可以暂停计算的monad ,这样您就可以暂停程序,进入并修改内部状态数据,然后恢复它.

您可以将"continuation"实现为monad.这可以让你打破人们的思想!

monad可以实现所有这些以及更多.当然,如果没有 monad ,所有这一切也是完全可能的.使用monads 非常容易.

来自非数学,非函数式编程背景,这个答案对我来说最有意义.

我很感激你的答案 - 特别是最后的让步,所有这一切当然也可能没有单子.有一点需要注意的是,使用monad它们*更容易*,但它通常不如没有它们那样有效.一旦您需要涉及变换器,函数调用(以及创建的函数对象)的额外分层具有难以查看和控制的成本,通过巧妙的语法呈现为不可见.

这是第一个真正让我知道monad是什么的答案.感谢您找到解释它的方法!

你的答案绝对精彩!万分感谢!

3> 小智..：

实际上,与莫纳德的共同理解相反,他们与国家无关.Monads只是一种包装东西的方法,并提供了对包裹的东西进行操作的方法,而无需展开它.

例如,您可以在Haskell中创建一个类型来包装另一个类型:

data Wrapped a = Wrap a

包装我们定义的东西

return :: a -> Wrapped a
return x = Wrap x

要在不解包的情况下执行操作,假设您有一个函数f :: a -> b,那么您可以执行此操作来解除该函数以对包装值执行操作:

fmap :: (a -> b) -> (Wrapped a -> Wrapped b)
fmap f (Wrap x) = Wrap (f x)

这就是所有需要了解的内容.然而,事实证明,有一个更通用的功能来完成这个提升,这是bind:

bind :: (a -> Wrapped b) -> (Wrapped a -> Wrapped b)
bind f (Wrap x) = f x

bind可以做多一点fmap,但反之亦然.实际上,fmap只能用bind和来定义return.因此,在定义monad时...你给它的类型(这里是Wrapped a),然后说出它return和bind操作是如何工作的.

很酷的是,事实证明这是一种普遍的模式,它会在整个地方弹出,以纯粹的方式封装状态只是其中之一.

有关如何使用monad来引入函数依赖关系并因此控制评估顺序的好文章,就像它在Haskell的IO monad中使用一样,请查看IO Inside.

至于理解monad,不要太担心它.阅读他们您感兴趣的内容,如果您不理解,请不要担心.然后,只需要像Haskell这样的语言潜水就可以了.Monads是通过练习理解涓涓细流到你的大脑的其中一件事,有一天你突然意识到你理解它们.

@ mb21:如果您只是指出支架太多,请注意a-> b-> c实际上只是 - >(b-> c)的缩写.将这个特定的例子写成(a - > b) - >(Ta - > Tb)严格来说只是添加不必要的字符,但它在道德上是"正确的事情",因为它强调fmap映射类型a的函数 - > b到Ta - > Tb类型的函数.最初,这就是算子在类别理论中所做的事情,也就是monad来自哪里.

4> nlucaroni..：

但是,你可能已经发明了Monads!

sigfpe说:

但是所有这些都将monad引入了需要解释的深奥的东西.但我想说的是,它们根本不是深奥的.事实上,面对函数式编程中的各种问题,你不可避免地会遇到某些解决方案,所有解决方案都是monad的例子.事实上,如果你还没有,我希望你现在可以发明它们.然后,这是一个小步骤,注意到所有这些解决方案实际上都是伪装的相同解决方案.阅读本文之后,你可能会更好地理解monad上的其他文档,因为你会认识到你所看到的所有你已经发明的东西.

monad试图解决的许多问题都与副作用问题有关.所以我们将从他们开始.(注意monads让你做的不仅仅是处理副作用,特别是许多类型的容器对象可以被视为monad.对monad的一些介绍发现很难调和monad的这两种不同用法并且只关注一个或者另一个.)

在诸如C++这样的命令式编程语言中,函数的行为与数学函数完全不同.例如,假设我们有一个C++函数,它接受一个浮点参数并返回一个浮点结果.从表面上看,它似乎有点像数学函数映射实数到实数,但C++函数可以做的不仅仅是返回一个取决于其参数的数字.它可以读取和写入全局变量的值,也可以将输出写入屏幕并接收来自用户的输入.但是,在纯函数式语言中,函数只能读取其参数中提供给它的内容,并且它对世界产生影响的唯一方法是通过它返回的值.

[这个Sigfpe帖子的JavaScript翻译](https://blog.jcoglan.com/2011/03/05/translation-from-haskell-to-javascript-of-selected-portions-of-the-best-introduction-to -monads-ive-ever-read /)是学习monad的新方法,对于那些还没有学过高级Haskell的人来说!

...最好的方式不仅在互联网上,而且在任何地方.(Wadler的原始论文[Monads for functions programming](http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf)我在下面的回答中提到的也很好.)没有数以万计的教程比较接近.

5> Chris Conway..：

monad是一种具有两个操作的数据类型:>>=(aka bind)和return(aka unit).return获取任意值并使用它创建monad的实例.>>=获取monad的实例并在其上映射函数.(您已经可以看到monad是一种奇怪的数据类型,因为在大多数编程语言中,您无法编写一个采用任意值并从中创建类型的函数.Monads使用一种参数多态.)

在Haskell表示法中,编写了monad接口

class Monad m where
  return :: a -> m a
  (>>=) :: forall a b . m a -> (a -> m b) -> m b

这些操作都应该遵守一定的"规律",但是这不是很重要了:"法律"只是编纂操作的方式明智的实现应该表现(基本上,>>=并return应该同意的价值观是如何被转化成单子实例和这>>=是关联的).

Monads不只是关于状态和I/O:它们抽象了一种常见的计算模式,包括使用状态,I/O,异常和非确定性.可能最容易理解的monad是列表和选项类型:

instance Monad [ ] where
    []     >>= k = []
    (x:xs) >>= k = k x ++ (xs >>= k)
    return x     = [x]

instance Monad Maybe where
    Just x  >>= k = k x
    Nothing >>= k = Nothing
    return x      = Just x

其中[]和:是列表构造函数,++是连接运算符,Just并且Nothing是Maybe构造函数.这两个monad都在各自的数据类型上封装了常见且有用的计算模式(请注意,这两种模式都与副作用或I/O无关).

你真的必须编写一些非平凡的Haskell代码,以了解monad的含义以及它们有用的原因.

Monad不是数据类型。这是组成函数的规则：http://stackoverflow.com/a/37345315/1614973

6> Apocalisp..：

你应该先了解一个仿函数是什么.在此之前,了解更高阶的函数.

甲高阶函数是一个简单的函数,它的功能作为一个参数.

甲算符是任何类型的构造T为其中存在一个高阶函数,调用它map,该变换类型的函数a -> b(给定任何两种类型的a和b)成一个函数T a -> T b.此map函数还必须遵守身份和组合的规律,以便以下表达式对所有人p和q(Haskell表示法)都返回true :

map id = id
map (p . q) = map p . map q

例如,如果一个类型构造List函数配备了(a -> b) -> List a -> List b符合上述规则的类型函数,则它被称为仿函数.唯一实际的实施是显而易见的.结果List a -> List b函数遍历给定列表,(a -> b)为每个元素调用函数,并返回结果列表.

一个单子本质上只是一个仿函数T有两个额外的方法,join,类型T (T a) -> T a,和unit(有时被称为return,fork或pure类型)a -> T a.对于Haskell中的列表:

join :: [[a]] -> [a]
pure :: a -> [a]

为什么这有用？例如,因为您可以map在具有返回列表的函数的列表上.Join获取结果列表并将它们连接起来.List是monad,因为这是可能的.

你可以写,做了功能map,那么join.此函数被称为bind,或flatMap,或(>>=),或(=<<).这通常是在Haskell中给出monad实例的方式.

monad必须满足某些定律,即join必须是关联的.这意味着如果你有一个x类型的值,[[[a]]]那么join (join x)应该相等join (map join x).而且pure必须是一个身份join,使得join (pure x) == x.

根据该定义,加法是高阶函数.它需要一个数字并返回一个将该数字添加到另一个数字的函数.所以不,高阶函数是严格的函数,其域由函数组成.

稍微增加'更高阶函数'的def:它们可以采用OR RETURN函数.这就是为什么他们"更高",因为他们自己做事.

7> Aristotle Pa..：

[免责声明:我仍然试图完全修改monad.以下是我到目前为止所理解的内容.如果这是错的,希望知识渊博的人会叫我在地毯上.]

阿纳写道:

Monads只是一种包装东西的方法,并提供了对包裹的东西进行操作的方法,而无需展开它.

这正是它.这个想法是这样的:

你需要一些价值并用一些额外的信息包装它.就像值是某种类型(例如,整数或字符串)一样,附加信息也是某种类型.

例如,额外的信息可能是a Maybe或a IO.

然后,您有一些运算符,允许您在携带附加信息的同时对包装数据进行操作.这些运算符使用附加信息来决定如何更改包装值上的操作行为.

例如,a Maybe Int可以是a Just Int或Nothing.现在,如果你添加一个Maybe Int到Maybe Int,运营商将检查,看看他们都是Just Int里面装的,如果是的话,那里展开IntS,通过他们的加法运算,形成的再包装Int到一个新的Just Int(这是一个有效Maybe Int),从而返回一个Maybe Int.但是如果其中一个是Nothing内部的,那么这个操作符将立即返回Nothing,这也是有效的Maybe Int.这样,您可以假装您的Maybe Ints只是正常数字并对它们进行常规数学运算.如果你得到一个Nothing,你的方程式仍将产生正确的结果 - 你无需在Nothing任何地方乱丢垃圾.

但这个例子正是发生了什么Maybe.如果额外信息是a IO,那么为IOs 定义的特殊运算符将被调用,并且在执行添加之前它可以做一些完全不同的事情.(好吧,将两个IO Ints加在一起可能是荒谬的 - 我还不确定.)(另外,如果你注意这个Maybe例子,你已经注意到"用额外的东西包装一个值"并不总是正确的.但它很难确切,准确,准确,不可理解.)

基本上,"monad"大致意味着"模式".但是,您现在拥有一个语言结构 - 语法和全部 - 而不是一本充满非正式解释和特别命名的模式的书,它允许您将新模式声明为程序中的事物.(这里的不精确是所有的模式都必须遵循一种特定的形式,所以monad并不像模式那样通用.但我认为这是大多数人都知道和理解的最接近的术语.)

这就是人们发现monad如此混乱的原因:因为它们是如此通用的概念.要问是什么使monad成为同样含糊不清的问题是什么使某事成为一种模式.

但是想一想在语言中使用语法支持对模式概念的影响:你不必阅读" 四人帮"一书并记住特定模式的构造,你只需编写一个在不可知的情况下实现这种模式的代码,一般的方式,然后你就完成了!然后,您可以重复使用此模式,例如Visitor或Strategy或Façade等等,只需通过使用它来装饰代码中的操作,而无需反复重复实现它!

所以这就是为什么理解 monad的人发现它们如此有用:它不是一些象牙塔概念,知识分子自豪于理解(好吧,当然,teehee),但实际上使代码更简单.

一书并记住特定模式的构造,你只需