在最近简要回顾了Haskell之后,对于monad本质上是什么,有什么简单、简洁、实用的解释?
我发现,我遇到的大多数解释都很难理解,而且缺乏实际细节。
在最近简要回顾了Haskell之后,对于monad本质上是什么,有什么简单、简洁、实用的解释?
我发现,我遇到的大多数解释都很难理解,而且缺乏实际细节。
当前回答
一个非常简单的答案是:
Monad是一种抽象,它为封装值、计算新的封装值和展开封装值提供了接口。
它们在实践中的方便之处在于,它们提供了一个统一的接口,用于创建建模状态而非状态的数据类型。
必须理解Monad是一种抽象,即用于处理某种数据结构的抽象接口。然后,该接口用于构建具有一元行为的数据类型。
你可以在Ruby中的Monads中找到一个非常好且实用的介绍,第1部分:简介。
其他回答
第一:如果你不是数学家,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添加到语言中。
Monad是一种带有特殊机器的盒子,它允许你从两个嵌套的盒子中制作一个普通的盒子,但仍然保持两个盒子的一些形状。
具体来说,它允许您执行连接,类型为Monad m=>m(m a)->m a。
它还需要一个返回操作,它只包装一个值。return::Monad m=>a->m a你也可以说joinunboxes和return wrappes,但join不是Monad m=>m a->a类型的(它不会打开所有Monad,而是打开Monad,Monad在其中)
所以它取一个Monad盒子(Monad m=>,m),里面有一个盒子((m a)),然后生成一个普通盒子(m a。
然而,Monad通常用于(>>=)(口语“bind”)运算符,它本质上只是一个fmap和一个接一个的join。具体而言,
x >>= f = join (fmap f x)
(>>=) :: Monad m => (a -> m b) -> m a -> m b
请注意,函数出现在第二个参数中,而不是fmap。
此外,join=(>>=id)。
为什么这有用?本质上,它允许您在某种框架(Monad)中工作时制作将动作串在一起的程序。
Haskell中Monad的最突出用途是IO Monad。现在,IO是对Haskell中的Action进行分类的类型。在这里,Monad系统是唯一的保存方式(华丽的词):
参考透明度懒惰纯洁
本质上,像getLine::IOString这样的IO操作不能被String替换,因为它总是具有不同的类型。把IO想象成一种神奇的盒子,可以把东西传送给你。然而,仍然只是说getLine::IOString和所有函数都接受IOa会导致混乱,因为可能不需要这些函数。const“üp§”getLine会做什么?(const丢弃第二个参数。const a b=a。)getLine不需要求值,但应该执行IO!这使得行为相当不可预测,也使得类型系统不那么“纯粹”,因为所有函数都将采用a和IOa值。
输入IO Monad。
要将动作串在一起,只需展平嵌套的动作。要将函数应用于IO操作的输出,IO a类型中的a,只需使用(>>=)。
例如,输出输入的行(输出行是一个生成IO操作的函数,匹配右参数>>=):
getLine >>= putStrLn :: IO ()
-- putStrLn :: String -> IO ()
这可以用do环境更直观地写出来:
do line <- getLine
putStrLn line
本质上,这样的do块:
do x <- a
y <- b
z <- f x y
w <- g z
h x
k <- h z
l k w
…转化为:
a >>= \x ->
b >>= \y ->
f x y >>= \z ->
g z >>= \w ->
h x >>= \_ ->
h z >>= \k ->
l k w
还有m>>=\_->f的>>运算符(当框中的值不需要在框中创建新框时)也可以写成a>>b=a>>=constb(consta b=a)
此外,返回运算符是根据IO直觉建模的-它返回一个具有最小上下文的值,在这种情况下没有IO。由于IO a中的a表示返回的类型,这类似于命令式编程语言中的return(a),但它不会停止操作链!f>>=return>>=g与f>>=g相同。仅当您返回的术语在链中较早创建时才有用-请参见上文。
当然,还有其他Monad,否则它不会被称为Monad,它会被称为“IO控制”之类的东西。
例如,List Monad(Monad[])通过串联变平-使(>>=)运算符对列表的所有元素执行函数。这可以被视为“不确定性”,其中列表是许多可能的值,而Monad框架正在进行所有可能的组合。
例如(GHCi):
Prelude> [1, 2, 3] >>= replicate 3 -- Simple binding
[1, 1, 1, 2, 2, 2, 3, 3, 3]
Prelude> concat (map (replicate 3) [1, 2, 3]) -- Same operation, more explicit
[1, 1, 1, 2, 2, 2, 3, 3, 3]
Prelude> [1, 2, 3] >> "uq"
"uququq"
Prelude> return 2 :: [Int]
[2]
Prelude> join [[1, 2], [3, 4]]
[1, 2, 3, 4]
因为:
join a = concat a
a >>= f = join (fmap f a)
return a = [a] -- or "= (:[])"
如果出现这种情况,“也许莫纳德”只会将所有结果作废为“无”。也就是说,绑定自动检查函数(a>>=f)是否返回或值(a>>>=f)是否为Nothing,然后也返回Nothing。
join Nothing = Nothing
join (Just Nothing) = Nothing
join (Just x) = x
a >>= f = join (fmap f a)
或者更明确地说:
Nothing >>= _ = Nothing
(Just x) >>= f = f x
State Monad用于同时修改某些共享状态-s->(a,s)的函数,因此>>=的参数为:a->s->(a,s)。这个名称有点用词不当,因为State实际上是用于状态修改功能,而不是用于状态——状态本身确实没有有趣的财产,它只是被改变了。
例如:
pop :: [a] -> (a , [a])
pop (h:t) = (h, t)
sPop = state pop -- The module for State exports no State constructor,
-- only a state function
push :: a -> [a] -> ((), [a])
push x l = ((), x : l)
sPush = state push
swap = do a <- sPop
b <- sPop
sPush a
sPush b
get2 = do a <- sPop
b <- sPop
return (a, b)
getswapped = do swap
get2
那么:
Main*> runState swap [1, 2, 3]
((), [2, 1, 3])
Main*> runState get2 [1, 2, 3]
((1, 2), [1, 2, 3]
Main*> runState (swap >> get2) [1, 2, 3]
((2, 1), [2, 1, 3])
Main*> runState getswapped [1, 2, 3]
((2, 1), [2, 1, 3])
也:
Prelude> runState (return 0) 1
(0, 1)
monad是一种具有两个操作的数据类型:>>=(又名bind)和return(又名unit)。return接受一个任意值并用它创建monad的实例。>>=接受monad的一个实例并在其上映射一个函数。(您已经可以看到monad是一种奇怪的数据类型,因为在大多数编程语言中,您无法编写一个接受任意值并从中创建类型的函数。monad使用一种参数多态性。)
在Haskell表示法中,monad接口是
class Monad m where
return :: a -> m a
(>>=) :: forall a b . m a -> (a -> m b) -> m b
这些操作应该遵守某些“法则”,但这并不是非常重要的:“法则”只是将操作的合理实现行为化(基本上,>>=和return应该就如何将值转换为monad实例达成一致,并且>>=是关联的)。
Monad不仅仅是关于状态和I/O:它们抽象了一种常见的计算模式,包括处理状态、I/O、异常和非确定性。可能最容易理解的单子是列表和选项类型:
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是一种函数组合技术,它使用组合函数bind将某些输入场景的处理具体化,以在组合过程中预处理输入。
在正常合成中,函数compose(>>)用于按顺序将合成的函数应用于其前身的结果。重要的是,所组成的函数需要处理其输入的所有场景。
(x->y)>>(y->z)
这种设计可以通过重组输入来改进,以便更容易地询问相关状态。因此,如果y包含有效性的概念,则值可以变成Mb,例如(is_OK,b),而不是简单的y。
例如,当输入仅可能是一个数字时,而不是返回一个可以尽职尽责地包含数字或不包含数字的字符串,您可以将类型重新构造为bool,以指示元组中存在有效数字和数字,例如bool*float。组合函数现在不再需要解析输入字符串来确定数字是否存在,而只需要检查元组的布尔部分。
(Ma->Mb)>>(Mb->Mc)
在这里,合成与合成一起自然发生,因此每个函数必须单独处理其输入的所有场景,尽管现在这样做要容易得多。
然而,如果我们能够将审讯的工作外化,以应对那些处理场景是常规的情况,那又会怎样呢。例如,如果我们的程序在输入不正常时什么都不做,比如is_OK为false时。如果做到了这一点,那么组合函数就不需要自己处理该场景,从而大大简化了代码并实现了另一个级别的重用。
为了实现这种外部化,我们可以使用bind(>>=)函数来执行组合而不是组合。因此,不是简单地将值从一个函数的输出传递到另一个函数输入,而是检查Ma的M部分,并决定是否以及如何将组合函数应用于a。当然,函数绑定将专门为我们的特定M定义,以便能够检查其结构并执行我们想要的任何类型的应用。尽管如此,a可以是任何东西,因为bind仅在确定应用程序需要时将未检查的a传递给组合函数。此外,组合函数本身也不再需要处理输入结构的M部分,从而简化了它们。因此
(a->Mb)>>=(b->Mc)或更简洁地Mb>>=
简言之,一旦输入被设计为充分暴露某些输入场景,monad就外部化了,从而提供了关于处理这些输入场景的标准行为。这种设计是一种外壳和内容模型,其中外壳包含与组合函数的应用程序相关的数据,并由绑定函数查询,并且仅对绑定函数可用。
因此,单子是三件事:
M外壳,用于保存monad相关信息,实现的绑定函数,用于在将组合函数应用于其在外壳中找到的内容值时使用该外壳信息,以及形式为a->Mb的可组合函数,生成包含单元管理数据的结果。
一般来说,函数的输入比其输出更具限制性,其中可能包括错误条件等;因此,Mb结果结构通常非常有用。例如,当除数为0时,除法运算符不返回数字。
此外,monad可以包括将值a包装成monadic类型Ma的包装函数,以及将一般函数a->b包装成monodic函数a->Mb的包装函数。当然,像bind一样,这样的包装函数是M特有的。例如:
let return a = [a]
let lift f a = return (f a)
绑定函数的设计假定了不可变的数据结构和纯函数,其他事情变得复杂,无法保证。因此,有一元定律:
鉴于
M_
return = (a -> Ma)
f = (a -> Mb)
g = (b -> Mc)
然后
Left Identity : (return a) >>= f === f a
Right Identity : Ma >>= return === Ma
Associative : Ma >>= (f >>= g) === Ma >>= ((fun x -> f x) >>= g)
关联性意味着无论何时应用绑定,绑定都会保留求值顺序。也就是说,在上述关联性的定义中,对f和g的括号化绑定的强制早期评估只会导致期望Ma的函数完成绑定。因此,必须先确定Ma的值,然后才能将其值应用于f,进而将结果应用于g。
世界需要的是另一篇monad博客文章,但我认为这对识别野外现存的monad很有用。
单子是分形
上面是一个叫做Sierpinski三角形的分形,这是我唯一记得画的分形。分形是与上述三角形相似的自相似结构,其中部分与整体相似(在这种情况下,正好是母三角形比例的一半)。单子是分形。给定一个一元数据结构,它的值可以组合成数据结构的另一个值。这就是为什么它对编程有用,这也是为什么它在许多情况下都会出现。