(注:这是对“如何解释
IO
对初学者来说很有用。它并不试图解释
RealWorld#
黑客GHC使用。的确,后者不是一个好的介绍方式
输入输出
.)
有很多方法可以向初学者解释IO monad。这很难,因为不同的人在心理上将单子与不同的想法联系在一起。您可以使用范畴理论,或者将它们描述为可编程分号,甚至
burritos
.
正因为如此,当我在过去尝试这样做的时候,我通常会尝试很多方法,直到其中一种方法“点击”到学习者的心理模式。了解他们的背景有很大帮助。
命令闭包
例如,当学习者已经熟悉一些带有闭包的命令式语言(例如JavaScript)时,我倾向于告诉他们,他们可以假装Haskell程序的全部目的是生成JavaScript闭包,然后使用JavaScript实现运行。在这个虚假的解释中
IO T
type代表封装JavaScript闭包的不透明类型,在运行时,它将生成类型为
T
,可能是在引起一些副作用之后——就像JavaScript所做的那样。
所以,一个值
f :: IO String
可实施为
let f = () => {
print("side effect");
return "result";
};
和
g :: IO ()
可实施为
let g = () => {
print("g here");
return {};
};
现在,假设
f
闭包,如何从Haskell调用它?好吧,我们不能直接这么做,因为哈斯克尔想控制副作用。也就是说,我们不能
f ++ "hi"
或
f() ++ "hi"
.
相反,要“调用闭包”,我们可以将其绑定到
main
main :: IO ()
main = g
的确,
主要的
是整个Haskell程序生成的JavaScript闭包,它将由Haskell实现调用。
好的,现在的问题是:“如何调用多个闭包?”为此,可以介绍
>>
假装它是作为
function andThenSimple(f, g) {
return () => {
f();
return g();
};
}
或者,为了
>>=
:
function andThen(f, g) {
return () => {
let x = f();
return g(x)(); // pass x, and then invoke the resulting closure
};
}
return
比较容易
function ret(x) {
return () => x;
}
这些函数需要一段时间才能解释,但如果理解闭包,就不难理解它们。
纯功能(又名免费)
另一个选择是保持一切纯洁。或者至少尽可能纯净。你可以假装
IO a
是不透明类型,定义为
data IO a
= Return a
| Output String (IO a)
| Input (String -> IO a)
-- ... other IO operations here
然后假装
main :: IO ()
然后由某个命令引擎“运行”。像这样的程序
foo :: IO Int
foo = do
l <- getLine
putStrLn l
putStrLn l
return (length l)
实际上,根据这个解释,
foo :: IO Int
foo = Input (\l -> Output l (Output l (Return (length l))))
当然在这里
return = Return
,并定义
>>=
是个很好的锻炼。
咖喱杂质
忘了IO,monads,还有那些东西。我们可以更好地理解两个简单的概念
a -> b -- pure function type
a ~> b -- impure function type
后者是一个假想的哈斯克尔类型。大多数程序员应该能够对这些类型表示的内容有很强的直觉。
现在,在函数式编程中,我们有curring,它是
(a, b) -> c
和
a -> b -> c
经过一番思考,我们可以看到不纯洁的函数也应该承认一些讨好。我们确实可以确信,应该有一些类似于
(a, b) ~> c
<===>
a ~> b ~> c
再想一想,你甚至可以明白
~>
在里面
a ~> b ~> c
实际上是不准确的。上面的curried函数在
a
只有一个人在过去——这是
b
这会触发原始未载波函数的执行,导致副作用。
所以,考虑到这一点,我们可以认为咖喱是
(a, b) ~> c
<===>
a -> b ~> c
--^^-- pure!
作为一个特殊的例子,我们得到了同构
(a, ()) ~> c
<===>
a -> () ~> c
更进一步,因为
(a, ())
同构于
一
(这里需要更具说服力的解释),我们可以将curring解释为
a ~> c
<===>
a -> () ~> c
现在,如果我们洗礼
() ~> c
作为
IO c
,我们得到
a ~> c
<===>
a -> IO c
啊哈!这告诉我们,我们并不真正需要一般的不纯函数类型
a ~> c
. 只要我们有它的特例
IO c = () ~> c
,我们可以表示(直到同构)任何
a~>c类
功能。
从这里,人们可以开始在脑海中描绘出
输入输出电流
应该起作用,最终实现其一元结构。本质上,这种解释
输入输出电流
现在与上面给出的利用闭包的方法非常相似。