blocks|key|1863132|text|Monads只是一个用于解决一类重复出现的问题的方便框架。首先，monads必须是functors+(即必须支持映射而不查看元素(或其类型))，它们还必须带来绑定(或链接)操作和从元素类型(return)创建一元值的方法。最后，bind和return必须满足两个等式(左等式和右等式)，也称为单数定律。(或者，可以将monads定义为具有flattening+operation而不是绑定。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1863133|list+monad通常用于处理非确定性。绑定操作选择列表中的一个元素(直观地说，所有元素都在并行世界中)，让程序员对它们进行一些计算，然后将所有世界中的结果组合到单个列表中(通过连接或扁平嵌套列表)。下面是如何在Haskell的一元框架中定义置换函数：|1863134|perm+[e]+=+[[e]]
perm+l+=+do+(leader,+index)+<-+zip+l+[0+::+Int+..]
++++++++++++let+shortened+=+take+index+l+%2B%2B+drop+(index+%2B+1)+l
++++++++++++trailer+<-+perm+shortened
++++++++++++return+(leader+:+trailer)|code-block|syntax|javascript|1863135|下面是一个repl会话示例：|1863136|*Main>+perm+"a"
["a"]
*Main>+perm+"ab"
["ab","ba"]
*Main>+perm+""
[]
*Main>+perm+"abc"
["abc","acb","bac","bca","cab","cba"]|1863137|应该注意的是，list+monad绝不是影响计算的副作用。一个数学结构是一个单体(即符合上面提到的界面和定律)并不意味着副作用，尽管副作用现象通常很好地适合一元论框架。|1863138|entityMap^0|2N|6|36|4|3B|6|4P|K|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|T|$]]

Monads are just a convenient framework for solving a class of recurring problems. First, monads must be functors (i.e. must support mapping without looking at the elements (or their type)), they must also bring a binding (or chaining) operation and a way to create a monadic value from an element type (<code>return</code>). Finally, <code>bind</code> and <code>return</code> must satisfy two equations (left and right identities), also called the monad laws. (Alternatively one could define monads to have a <code>flattening operation</code> instead of binding.)

The list monad is commonly used to deal with non-determinism. The bind operation selects one element of the list (intuitively all of them in parallel worlds), lets the programmer to do some computation with them, and then combines the results in all worlds to single list (by concatenating, or flattening, a nested list). Here is how one would define a permutation function in the monadic framework of Haskell:

<pre><code>perm [e] = [[e]]
perm l = do (leader, index) &lt;- zip l [0 :: Int ..]
 let shortened = take index l ++ drop (index + 1) l
 trailer &lt;- perm shortened
 return (leader : trailer)
</code></pre>

Here is an example repl session:

<pre><code>*Main&gt; perm "a"
["a"]
*Main&gt; perm "ab"
["ab","ba"]
*Main&gt; perm ""
[]
*Main&gt; perm "abc"
["abc","acb","bac","bca","cab","cba"]
</code></pre>

It should be noted that the list monad is in no way a side effecting computation. A mathematical structure being a monad (i.e. conforming to the above mentioned interfaces and laws) does not imply side effects, though side-effecting phenomena often nicely fit into the monadic framework.

blocks|key|1863248|text|单体基本上是将函数组合在一起形成一个链。句号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1863249|现在，它们的组合方式在现有的monad中是不同的，因此导致了不同的行为(例如，在状态monad中模拟可变状态)。|1863250|关于monads的混乱之处在于，由于monads是如此通用，即一种组合函数的机制，它们可以用于许多事情，从而导致人们认为monads是关于状态、关于IO等的，而它们只是关于“组合函数”。|1863251|现在，关于monad的一个有趣的事情是，合成的结果总是"M+a“类型，也就是说，用"M”标记的信封内的值。这个特性恰好可以很好地实现，例如，在纯代码和不纯代码之间进行清晰的分离:将所有不纯操作声明为"IO+a“类型的函数，并且在定义IO+monad时不提供从"IO+a”内部取出"a“值的函数。结果是，没有一个函数可以是纯的，同时从"IO+a“中取出一个值，因为没有办法在保持纯的同时获取这样的值(函数必须在"IO”monad中才能使用这样的值)。(注意:没有什么是完美的，所以可以使用"unsafePerformIO+:+IO+a+->+a“打破"IO约束”，从而污染本应是纯函数的东西，但这应该非常谨慎地使用，并且当您真正知道不会引入任何具有副作用的不纯代码时。|1863252|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Monads serve basically to compose functions together in a chain. Period.

Now the way they compose differs across the existing monads, thus resulting in different behaviors (e.g., to simulate mutable state in the state monad).

The confusion about monads is that being so general, i.e., a mechanism to compose functions, they can be used for many things, thus leading people to believe that monads are about state, about IO, etc, when they are only about "composing functions".

Now, one interesting thing about monads, is that the result of the composition is always of type "M a", that is, a value inside an envelope tagged with "M". This feature happens to be really nice to implement, for example, a clear separation between pure from impure code: declare all impure actions as functions of type "IO a" and provide no function, when defining the IO monad, to take out the "a" value from inside the "IO a". The result is that no function can be pure and at the same time take out a value from an "IO a", because there is no way to take such value while staying pure (the function must be inside the "IO" monad to use such value). (NOTE: well, nothing is perfect, so the "IO straitjacket" can be broken using "unsafePerformIO : IO a -> a" thus polluting what was supposed to be a pure function, but this should be used very sparingly and when you really know to be not introducing any impure code with side-effects.

In my humble opinion the answers to the famous question <a href="https://stackoverflow.com/questions/44965/what-is-a-monad">"What is a monad?"</a>, especially the most voted ones, try to explain what is a monad without clearly explaining why monads are really necessary. Can they be explained as the solution to a problem?

Why do we need monads?

在我看来，著名问题的答案，特别是投票最多的问题，试图解释什么是monad，而没有清楚地解释为什么monad真的是必要的。它们能被解释为问题的解决方案吗？

问为什么我们需要monads？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们需要monads？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我们需要monads？
EN