[TOC]
# Monad
## pointed functor
在繼續(xù)后面的內(nèi)容之前，我得向你坦白一件事：關(guān)于我們先前創(chuàng)建的容器類型上的 `of` 方法，我并沒有說出它的全部實(shí)情。真實(shí)情況是，`of` 方法不是用來避免使用 `new` 關(guān)鍵字的，而是用來把值放到*默認(rèn)最小化上下文*（default minimal context）中的。是的，`of` 沒有真正地取代構(gòu)造器——它是一個(gè)我們稱之為 *pointed* 的重要接口的一部分。
> *pointed functor* 是實(shí)現(xiàn)了 `of` 方法的 functor。
這里的關(guān)鍵是把任意值丟到容器里然后開始到處使用 `map` 的能力。
```js
IO.of("tetris").map(concat(" master"));
// IO("tetris master")
Maybe.of(1336).map(add(1));
// Maybe(1337)
Task.of([{id: 2}, {id: 3}]).map(_.prop('id'));
// Task([2,3])
Either.of("The past, present and future walk into a bar...").map(
concat("it was tense.")
);
// Right("The past, present and future walk into a bar...it was tense.")
```
如果你還記得，`IO` 和 `Task` 的構(gòu)造器接受一個(gè)函數(shù)作為參數(shù)，而 `Maybe` 和 `Either` 的構(gòu)造器可以接受任意值。實(shí)現(xiàn)這種接口的動(dòng)機(jī)是，我們希望能有一種通用、一致的方式往 functor 里填值，而且中間不會涉及到復(fù)雜性，也不會涉及到對構(gòu)造器的特定要求。“默認(rèn)最小化上下文”這個(gè)術(shù)語可能不夠精確，但是卻很好地傳達(dá)了這種理念：我們希望容器類型里的任意值都能發(fā)生 `lift`，然后像所有的 functor 那樣再 `map` 出去。
有件很重要的事我必須得在這里糾正，那就是，`Left.of` 沒有任何道理可言，包括它的雙關(guān)語也是。每個(gè) functor 都要有一種把值放進(jìn)去的方式，對 `Either` 來說，它的方式就是 `new Right(x)`。我們?yōu)?`Right` 定義 `of` 的原因是，如果一個(gè)類型容器*可以* `map`，那它就*應(yīng)該* `map`?？瓷厦娴睦樱銘?yīng)該會對 `of` 通常的工作模式有一個(gè)直觀的印象，而 `Left` 破壞了這種模式。
你可能已經(jīng)聽說過 `pure`、`point`、`unit` 和 `return` 之類的函數(shù)了，它們都是 `of` 這個(gè)史上最神秘函數(shù)的不同名稱（譯者注：此處原文是“international function of mystery”，源自惡搞《007》的電影 *Austin Powers: International Man of Mystery*，中譯名《王牌大賤諜》）。`of` 將在我們開始使用 monad 的時(shí)候顯示其重要性，因?yàn)楹竺婺銜吹?，手?dòng)把值放回容器是我們自己的責(zé)任。
要避免 `new` 關(guān)鍵字，可以借助一些標(biāo)準(zhǔn)的 JavaScript 技巧或者類庫達(dá)到目的。所以從這里開始，我們就利用這些技巧或類庫，像一個(gè)負(fù)責(zé)任的成年人那樣使用 `of`。我推薦使用 `folktale`、`ramda` 或 `fantasy-land` 里的 functor 實(shí)例，因?yàn)樗鼈兺瑫r(shí)提供了正確的 `of` 方法和不依賴 `new` 的構(gòu)造器。
## 混合比喻
你看，除了太空墨西哥卷（如果你聽說過這個(gè)傳言的話）（譯者注：此處的傳言似乎是說一個(gè)叫 Chris Hadfield 的宇航員在國際空間站做墨西哥卷的事，[視頻鏈接](https://www.youtube.com/watch?v=f8-UKqGZ_hs)），monad 還被喻為洋蔥。讓我以一個(gè)常見的場景來說明這點(diǎn)：
```js
// Support
// ===========================
var fs = require('fs');
// readFile :: String -> IO String
var readFile = function(filename) {
return new IO(function() {
return fs.readFileSync(filename, 'utf-8');
});
};
// print :: String -> IO String
var print = function(x) {
return new IO(function() {
console.log(x);
return x;
});
}
// Example
// ===========================
// cat :: IO (IO String)
var cat = compose(map(print), readFile);
cat(".git/config")
// IO(IO("[core]\nrepositoryformatversion = 0\n"))
```
這里我們得到的是一個(gè) `IO`，只不過它陷進(jìn)了另一個(gè) `IO`。要想使用它，我們必須這樣調(diào)用： `map(map(f))`；要想觀察它的作用，必須這樣： `unsafePerformIO().unsafePerformIO()`。
```js
// cat :: String -> IO (IO String)
var cat = compose(map(print), readFile);
// catFirstChar :: String -> IO (IO String)
var catFirstChar = compose(map(map(head)), cat);
catFirstChar(".git/config")
// IO(IO("["))
```
盡管在應(yīng)用中把這兩個(gè)作用打包在一起沒什么不好的，但總感覺像是在穿著兩套防護(hù)服工作，結(jié)果就形成一個(gè)稀奇古怪的 API。再來看另一種情況：
```js
// safeProp :: Key -> {Key: a} -> Maybe a
var safeProp = curry(function(x, obj) {
return new Maybe(obj[x]);
});
// safeHead :: [a] -> Maybe a
var safeHead = safeProp(0);
// firstAddressStreet :: User -> Maybe (Maybe (Maybe Street) )
var firstAddressStreet = compose(
map(map(safeProp('street'))), map(safeHead), safeProp('addresses')
);
firstAddressStreet(
{addresses: [{street: {name: 'Mulburry', number: 8402}, postcode: "WC2N" }]}
);
// Maybe(Maybe(Maybe({name: 'Mulburry', number: 8402})))
```
這里的 functor 同樣是嵌套的，函數(shù)中三個(gè)可能的失敗都用了 `Maybe` 做預(yù)防也很干凈整潔，但是要讓最后的調(diào)用者調(diào)用三次 `map` 才能取到值未免也太無禮了點(diǎn)——我們和它才剛剛見面而已。這種嵌套 functor 的模式會時(shí)不時(shí)地出現(xiàn)，而且是 monad 的主要使用場景。
我說過 monad 像洋蔥，那是因?yàn)楫?dāng)我們用 `map` 剝開嵌套的 functor 以獲取它里面的值的時(shí)候，就像剝洋蔥一樣讓人忍不住想哭。不過，我們可以擦干眼淚，做個(gè)深呼吸，然后使用一個(gè)叫作 `join` 的方法。
```js
var mmo = Maybe.of(Maybe.of("nunchucks"));
// Maybe(Maybe("nunchucks"))
mmo.join();
// Maybe("nunchucks")
var ioio = IO.of(IO.of("pizza"));
// IO(IO("pizza"))
ioio.join()
// IO("pizza")
var ttt = Task.of(Task.of(Task.of("sewers")));
// Task(Task(Task("sewers")));
ttt.join()
// Task(Task("sewers"))
```
如果有兩層相同類型的嵌套，那么就可以用 `join` 把它們壓扁到一塊去。這種結(jié)合的能力，functor 之間的聯(lián)姻，就是 monad 之所以成為 monad 的原因。來看看它更精確的完整定義：
> monad 是可以變扁（flatten）的 pointed functor。
一個(gè) functor，只要它定義個(gè)了一個(gè) `join` 方法和一個(gè) `of` 方法，并遵守一些定律，那么它就是一個(gè) monad。`join` 的實(shí)現(xiàn)并不太復(fù)雜，我們來為 `Maybe` 定義一個(gè)：
```js
Maybe.prototype.join = function() {
return this.isNothing() ? Maybe.of(null) : this.__value;
}
```
看，就像子宮里雙胞胎中的一個(gè)吃掉另一個(gè)那么簡單。如果有一個(gè) `Maybe(Maybe(x))`，那么 `.__value` 將會移除多余的一層，然后我們就能安心地從那開始進(jìn)行 `map`。要不然，我們就將會只有一個(gè) `Maybe`，因?yàn)閺囊婚_始就沒有任何東西被 `map` 調(diào)用。
既然已經(jīng)有了 `join` 方法，我們把 monad 魔法作用到 `firstAddressStreet` 例子上，看看它的實(shí)際作用：
```js
// join :: Monad m => m (m a) -> m a
var join = function(mma){ return mma.join(); }
// firstAddressStreet :: User -> Maybe Street
var firstAddressStreet = compose(
join, map(safeProp('street')), join, map(safeHead), safeProp('addresses')
);
firstAddressStreet(
{addresses: [{street: {name: 'Mulburry', number: 8402}, postcode: "WC2N" }]}
);
// Maybe({name: 'Mulburry', number: 8402})
```
只要遇到嵌套的 `Maybe`，就加一個(gè) `join`，防止它們從手中溜走。我們對 `IO` 也這么做試試看，感受下這種感覺。
```js
IO.prototype.join = function() {
return this.unsafePerformIO();
}
```
同樣是簡單地移除了一層容器。注意，我們還沒有提及純粹性的問題，僅僅是移除過度緊縮的包裹中的一層而已。
```js
// log :: a -> IO a
var log = function(x) {
return new IO(function() { console.log(x); return x; });
}
// setStyle :: Selector -> CSSProps -> IO DOM
var setStyle = curry(function(sel, props) {
return new IO(function() { return jQuery(sel).css(props); });
});
// getItem :: String -> IO String
var getItem = function(key) {
return new IO(function() { return localStorage.getItem(key); });
};
// applyPreferences :: String -> IO DOM
var applyPreferences = compose(
join, map(setStyle('#main')), join, map(log), map(JSON.parse), getItem
);
applyPreferences('preferences').unsafePerformIO();
// Object {backgroundColor: "green"}
// <div style="background-color: 'green'"/>
```
`getItem` 返回了一個(gè) `IO String`，所以可以直接用 `map` 來解析它。`log` 和 `setStyle` 返回的都是 `IO`，所以必須要使用 `join` 來保證這里邊的嵌套處于控制之中。
## chain 函數(shù)
（譯者注：此處標(biāo)題原文是“My chain hits my chest”，是英國歌手 M.I.A 單曲 *Bad Girls* 的一句歌詞。據(jù)說這首歌有體現(xiàn)女權(quán)主義。）
你可能已經(jīng)從上面的例子中注意到這種模式了：我們總是在緊跟著 `map` 的后面調(diào)用 `join`。讓我們把這個(gè)行為抽象到一個(gè)叫做 `chain` 的函數(shù)里。
```js
// chain :: Monad m => (a -> m b) -> m a -> m b
var chain = curry(function(f, m){
return m.map(f).join(); // 或者 compose(join, map(f))(m)
});
```
這里僅僅是把 map/join 套餐打包到一個(gè)單獨(dú)的函數(shù)中。如果你之前了解過 monad，那你可能已經(jīng)看出來 `chain` 叫做 `>>=`（讀作 bind）或者 `flatMap`；都是同一個(gè)概念的不同名稱罷了。我個(gè)人認(rèn)為 `flatMap` 是最準(zhǔn)確的名稱，但本書還是堅(jiān)持使用 `chain`，因?yàn)樗?JS 里接受程度最高的一個(gè)。我們用 `chain` 重構(gòu)下上面兩個(gè)例子：
```js
// map/join
var firstAddressStreet = compose(
join, map(safeProp('street')), join, map(safeHead), safeProp('addresses')
);
// chain
var firstAddressStreet = compose(
chain(safeProp('street')), chain(safeHead), safeProp('addresses')
);
// map/join
var applyPreferences = compose(
join, map(setStyle('#main')), join, map(log), map(JSON.parse), getItem
);
// chain
var applyPreferences = compose(
chain(setStyle), chain(log), map(JSON.parse), getItem
);
```
我把所有的 `map/join` 都替換為了 `chain`，這樣代碼就顯得整潔了些。整潔固然是好事，但 `chain` 的能力卻不止于此——它更多的是龍卷風(fēng)而不是吸塵器。因?yàn)?`chain` 可以輕松地嵌套多個(gè)作用，因此我們就能以一種純函數(shù)式的方式來表示 *序列*（sequence） 和 *變量賦值*（variable assignment）。
```js
// getJSON :: Url -> Params -> Task JSON
// querySelector :: Selector -> IO DOM
getJSON('/authenticate', {username: 'stale', password: 'crackers'})
.chain(function(user) {
return getJSON('/friends', {user_id: user.id});
});
// Task([{name: 'Seimith', id: 14}, {name: 'Ric', id: 39}]);
querySelector("input.username").chain(function(uname) {
return querySelector("input.email").chain(function(email) {
return IO.of(
"Welcome " + uname.value + " " + "prepare for spam at " + email.value
);
});
});
// IO("Welcome Olivia prepare for spam at olivia@tremorcontrol.net");
Maybe.of(3).chain(function(three) {
return Maybe.of(2).map(add(three));
});
// Maybe(5);
Maybe.of(null).chain(safeProp('address')).chain(safeProp('street'));
// Maybe(null);
```
本來我們可以用 `compose` 寫上面的例子，但這將需要幾個(gè)幫助函數(shù)，而且這種風(fēng)格怎么說都要通過閉包進(jìn)行明確的變量賦值。相反，我們使用了插入式的 `chain`。順便說一下，`chain` 可以自動(dòng)從任意類型的 `map` 和 `join` 衍生出來，就像這樣：`t.prototype.chain = function(f) { return this.map(f).join(); }`。如果手動(dòng)定義 `chain` 能讓你覺得性能會好點(diǎn)的話（實(shí)際上并不會），我們也可以手動(dòng)定義它，盡管還必須要費(fèi)力保證函數(shù)功能的正確性——也就是說，它必須與緊接著后面有 `join` 的 `map` 相等。如果 `chain` 是簡單地通過結(jié)束調(diào)用 `of` 后把值放回容器這種方式定義的，那么就會造成一個(gè)有趣的后果，即可以從 `chain` 那里衍生出一個(gè) `map`。同樣地，我們還可以用 `chain(id)` 定義 `join`。聽起來好像是在跟魔術(shù)師玩德州撲克，魔術(shù)師想要什么牌就有什么牌；但是就像大部分的數(shù)學(xué)理論一樣，所有這些原則性的結(jié)構(gòu)都是相互關(guān)聯(lián)的。[fantasyland](https://github.com/fantasyland/fantasy-land) 倉庫中提到了許多上述衍生概念，這個(gè)倉庫也是 JavaScript 官方的代數(shù)數(shù)據(jù)結(jié)構(gòu)（algebraic data types）標(biāo)準(zhǔn)。
好了，我們來看上面的例子。第一個(gè)例子中，可以看到兩個(gè) `Task` 通過 `chain` 連接形成了一個(gè)異步操作的序列——它先獲取 `user`，然后用 `user.id` 查找 `user` 的 `friends`。`chain` 避免了 `Task(Task([Friend]))` 這種情況。
第二個(gè)例子是用 `querySelector` 查找?guī)讉€(gè) input 然后創(chuàng)建一條歡迎信息。注意看我們是如何在最內(nèi)層的函數(shù)里訪問 `uname` 和 `email` 的——這是函數(shù)式變量賦值的絕佳表現(xiàn)。因?yàn)?`IO` 大方地把它的值借給了我們，我們也要負(fù)起以同樣方式把值放回去的責(zé)任——不能辜負(fù)它的信任（還有整個(gè)程序的信任）。`IO.of` 非常適合做這件事，同時(shí)它也解釋了為何 pointed 這一特性是 monad 接口得以存在的重要前提。不過，`map` 也能返回正確的類型：
```js
querySelector("input.username").chain(function(uname) {
return querySelector("input.email").map(function(email) {
return "Welcome " + uname.value + " prepare for spam at " + email.value;
});
});
// IO("Welcome Olivia prepare for spam at olivia@tremorcontrol.net");
```
最后兩個(gè)例子用了 `Maybe`。因?yàn)?`chain` 其實(shí)是在底層調(diào)用了 `map`，所以如果遇到 `null`，代碼就會立刻停止運(yùn)行。
如果覺得這些例子不太容易理解，你也不必?fù)?dān)心。多跑跑代碼，多琢磨琢磨，把代碼拆開來研究研究，再把它們拼起來看看。總之記住，返回的如果是“普通”值就用 `map`，如果是 `functor` 就用 `chain`。
這里我得提醒一下，上述方式對兩個(gè)不同類型的嵌套容器是不適用的。functor 組合，以及后面會講到的 monad transformer 可以幫助我們應(yīng)對這種情況。
## 炫耀
這種容器編程風(fēng)格有時(shí)也能造成困惑，我們不得不努力理解一個(gè)值到底嵌套了幾層容器，或者需要用 `map` 還是 `chain`（很快我們就會認(rèn)識更多的容器類型）。使用一些技巧，比如重寫 `inspect` 方法之類，能夠大幅提高 debug 的效率。后面我們也會學(xué)習(xí)如何創(chuàng)建一個(gè)“棧”，使之能夠處理任何丟給它的作用（effects）。不過，有時(shí)候也需要權(quán)衡一下是否值得這樣做。
我很樂意揮起 monad 之劍，向你展示這種編程風(fēng)格的力量。就以讀一個(gè)文件，然后就把它直接上傳為例吧：
```js
// readFile :: Filename -> Either String (Future Error String)
// httpPost :: String -> Future Error JSON
// upload :: String -> Either String (Future Error JSON)
var upload = compose(map(chain(httpPost('/uploads'))), readFile);
```
這里，代碼不止一次在不同的分支執(zhí)行。從類型簽名可以看出，我們預(yù)防了三個(gè)錯(cuò)誤——`readFile` 使用 `Either` 來驗(yàn)證輸入（或許還有確保文件名存在）；`readFile` 在讀取文件的時(shí)候可能會出錯(cuò)，錯(cuò)誤通過 `readFile` 的 `Future` 表示；文件上傳可能會因?yàn)楦鞣N各樣的原因出錯(cuò)，錯(cuò)誤通過 `httpPost` 的 `Future` 表示。我們就這么隨意地使用 `chain` 實(shí)現(xiàn)了兩個(gè)嵌套的、有序的異步執(zhí)行動(dòng)作。
所有這些操作都是在一個(gè)從左到右的線性流中完成的，是完完全全純的、聲明式的代碼，是可以等式推導(dǎo)（equational reasoning）并擁有可靠特性（reliable properties）的代碼。我們沒有被迫使用不必要甚至令人困惑的變量名，我們的 `upload` 函數(shù)符合通用接口而不是特定的一次性接口。這些都是在一行代碼中完成的啊！
讓我們來跟標(biāo)準(zhǔn)的命令式的實(shí)現(xiàn)對比一下：
```js
// upload :: String -> (String -> a) -> Void
var upload = function(filename, callback) {
if(!filename) {
throw "You need a filename!";
} else {
readFile(filename, function(err, contents) {
if(err) throw err;
httpPost(contents, function(err, json) {
if(err) throw err;
callback(json);
});
});
}
}
```
看看，這簡直就是魔鬼的算術(shù)（譯者注：此處原文是“the devil's arithmetic”，為美國 1988 年出版的歷史小說，講述一個(gè)猶太小女孩穿越到 1942 年的集中營的故事。此書亦有同名改編電影，中譯名《穿梭集中營》），我們就像一顆彈珠一樣在變幻莫測的迷宮中穿梭。無法想象如果這是一個(gè)典型的應(yīng)用，而且一直在改變變量會怎樣——我們肯定會像陷入瀝青坑那樣無所適從。
# 理論
我們要看的第一條定律是結(jié)合律，但可能不是你熟悉的那個(gè)結(jié)合律。
```js
// 結(jié)合律
compose(join, map(join)) == compose(join, join)
```
這些定律表明了 monad 的嵌套本質(zhì)，所以結(jié)合律關(guān)心的是如何讓內(nèi)層或外層的容器類型 `join`，然后取得同樣的結(jié)果。用一張圖來表示可能效果會更好：
從左上角往下，先用 `join` 合并 `M(M(M a))` 最外層的兩個(gè) `M`，然后往左，再調(diào)用一次 `join`，就得到了我們想要的 `M a`?；蛘撸瑥淖笊辖峭?，先打開最外層的 `M`，用 `map(join)` 合并內(nèi)層的兩個(gè) `M`，然后再向下調(diào)用一次 `join`，也能得到 `M a`。不管是先合并內(nèi)層還是先合并外層的 `M`，最后都會得到相同的 `M a`，所以這就是結(jié)合律。值得注意的一點(diǎn)是 `map(join) != join`。兩種方式的中間步驟可能會有不同的值，但最后一個(gè) `join` 調(diào)用后最終結(jié)果是一樣的。
第二個(gè)定律與結(jié)合律類似：
```js
// 同一律 (M a)
compose(join, of) == compose(join, map(of)) == id
```
這表明，對任意的 monad `M`，`of` 和 `join` 相當(dāng)于 `id`。也可以使用 `map(of)` 由內(nèi)而外實(shí)現(xiàn)相同效果。我們把這個(gè)定律叫做“三角同一律”（triangle identity），因?yàn)榘阉鼒D形化之后就像一個(gè)三角形：
如果從左上角開始往右，可以看到 `of` 的確把 `M a` 丟到另一個(gè) `M` 容器里去了。然后再往下 `join`，就得到了 `M a`，跟一開始就調(diào)用 `id` 的結(jié)果一樣。從右上角往左，可以看到如果我們通過 `map` 進(jìn)到了 `M` 里面，然后對普通值 `a` 調(diào)用 `of`，最后得到的還是 `M (M a)`；再調(diào)用一次 `join` 將會把我們帶回原點(diǎn)，即 `M a`。
我要說明一點(diǎn)，盡管這里我寫的是 `of`，實(shí)際上對任意的 monad 而言，都必須要使用明確的 `M.of`。
我已經(jīng)見過這些定律了，同一律和結(jié)合律，以前就在哪兒見過...等一下，讓我想想...是的！它們是范疇遵循的定律！不過這意味著我們需要一個(gè)組合函數(shù)來給出一個(gè)完整定義。見證吧：
```js
var mcompose = function(f, g) {
return compose(chain(f), chain(g));
}
// 左同一律
mcompose(M, f) == f
// 右同一律
mcompose(f, M) == f
// 結(jié)合律
mcompose(mcompose(f, g), h) == mcompose(f, mcompose(g, h))
```
畢竟它們是范疇學(xué)里的定律。monad 來自于一個(gè)叫 “Kleisli 范疇”的范疇，這個(gè)范疇里邊所有的對象都是 monad，所有的態(tài)射都是聯(lián)結(jié)函數(shù)（chained funtions）。我不是要在沒有提供太多解釋的情況下，拿范疇學(xué)里各式各樣的概念來取笑你。我的目的是涉及足夠多的表面知識，向你說明這中間的相關(guān)性，讓你在關(guān)注日常實(shí)用特性之余，激發(fā)起對這些定律的興趣。
## 總結(jié)
monad 讓我們深入到嵌套的運(yùn)算當(dāng)中，使我們能夠在完全避免回調(diào)金字塔（pyramid of doom）情況下，為變量賦值，運(yùn)行有序的作用，執(zhí)行異步任務(wù)等等。當(dāng)一個(gè)值被困在幾層相同類型的容器中時(shí)，monad 能夠拯救它。借助 “pointed” 這個(gè)可靠的幫手，monad 能夠借給我們從盒子中取出的值，而且知道我們會在結(jié)束使用后還給它。
是的，monad 非常強(qiáng)大，但我們還需要一些額外的容器函數(shù)。比如，假設(shè)我們想同時(shí)運(yùn)行一個(gè)列表里的 api 調(diào)用，然后再搜集返回的結(jié)果，怎么辦？是可以使用 monad 實(shí)現(xiàn)這個(gè)任務(wù)，但必須要等每一個(gè) api 完成后才能調(diào)用下一個(gè)。合并多個(gè)合法性驗(yàn)證呢？我們想要的肯定是持續(xù)驗(yàn)證以搜集錯(cuò)誤列表，但是 monad 會在第一個(gè) `Left` 登場的時(shí)候停掉整個(gè)演出。
下一章，我們將看到 applicative functor 如何融入這個(gè)容器世界，以及為何在很多情況下它比 monad 更好用。
[第 10 章: Applicative Functor](ch10.md)
## 練習(xí)
```js
// 練習(xí) 1
// ==========
// 給定一個(gè) user，使用 safeProp 和 map/join 或 chain 安全地獲取 sreet 的 name
var safeProp = _.curry(function (x, o) { return Maybe.of(o[x]); });
var user = {
id: 2,
name: "albert",
address: {
street: {
number: 22,
name: 'Walnut St'
}
}
};
var ex1 = undefined;
// 練習(xí) 2
// ==========
// 使用 getFile 獲取文件名并刪除目錄，所以返回值僅僅是文件，然后以純的方式打印文件
var getFile = function() {
return new IO(function(){ return __filename; });
}
var pureLog = function(x) {
return new IO(function(){
console.log(x);
return 'logged ' + x;
});
}
var ex2 = undefined;
// 練習(xí) 3
// ==========
// 使用 getPost() 然后以 post 的 id 調(diào)用 getComments()
var getPost = function(i) {
return new Task(function (rej, res) {
setTimeout(function () {
res({ id: i, title: 'Love them tasks' });
}, 300);
});
}
var getComments = function(i) {
return new Task(function (rej, res) {
setTimeout(function () {
res([
{post_id: i, body: "This book should be illegal"},
{post_id: i, body: "Monads are like smelly shallots"}
]);
}, 300);
});
}
var ex3 = undefined;
// 練習(xí) 4
// ==========
// 用 validateEmail、addToMailingList 和 emailBlast 實(shí)現(xiàn) ex4 的類型簽名
// addToMailingList :: Email -> IO([Email])
var addToMailingList = (function(list){
return function(email) {
return new IO(function(){
list.push(email);
return list;
});
}
})([]);
function emailBlast(list) {
return new IO(function(){
return 'emailed: ' + list.join(',');
});
}
var validateEmail = function(x){
return x.match(/\S+@\S+\.\S+/) ? (new Right(x)) : (new Left('invalid email'));
}
// ex4 :: Email -> Either String (IO String)
var ex4 = undefined;
```
