[TOC]
# Applicative Functor
## 應(yīng)用 applicative functor
考慮到其函數(shù)式的出身，**applicative functor** 這個名稱堪稱簡單明了。函數(shù)式程序員最為人詬病的一點就是，總喜歡搞一些稀奇古怪的命名，比如 `mappend` 或者 `liftA4`。誠然，此類名稱出現(xiàn)在數(shù)學(xué)實驗室是再自然不過的，但是放在其他任何語境下，這些概念就都像是扮作達(dá)斯維達(dá)去汽車餐館搞怪的人。（譯者注：此處需要做些解釋，1. 汽車餐館（drive-thru）指的是那種不需要顧客下車就能提供服務(wù)的地方，比如麥當(dāng)勞、星巴克等就會有這種 drive-thru；2. 達(dá)斯維達(dá)（Darth Vader）是《星球大戰(zhàn)》系列主要反派角色，在美國大眾文化中的有著廣泛的影響力，其造型是很多人致敬模仿的對象；3. 由于 2 的緣故，美國一些星戰(zhàn)迷會扮作 Darth Vader 去 drive-thru 點單，YouTube 上有不少這種[搞怪視頻](https://www.youtube.com/watch?v=eKVJZAMUh_A)；4. 作者使用這個“典故”是為了說明函數(shù)式里很多概念的名稱有些“故弄玄虛”，而 applicative functor 是少數(shù)比較“正常”的。）
無論如何，applicative 這個名字應(yīng)該能夠向我們表明一些事實，告訴我們作為一個接口，它能為我們帶來什么：那就是讓不同 functor 可以相互應(yīng)用（apply）的能力。
然而，你可能為會問了，為何一個正常的、理性的人，比如你自己，會做這種“讓不同 functor 相互應(yīng)用”的事？而且，“相互應(yīng)用”到底*是什么意思*？
要回答這些問題，我們可以從下面這個場景講起，可能你已經(jīng)碰到過這種場景了。假設(shè)有兩個同類型的 functor，我們想把這兩者作為一個函數(shù)的兩個參數(shù)傳遞過去來調(diào)用這個函數(shù)。簡單的例子比如讓兩個 `Container` 的值相加：
```js
// 這樣是行不通的，因為 2 和 3 都藏在瓶子里。
add(Container.of(2), Container.of(3));
//NaN
// 使用可靠的 map 函數(shù)試試
var container_of_add_2 = map(add, Container.of(2));
// Container(add(2))
```
這時候我們創(chuàng)建了一個 `Container`，它內(nèi)部的值是一個局部調(diào)用的（partially applied）的函數(shù)。確切點講就是，我們想讓 `Container(add(2))` 中的 `add(2)` 應(yīng)用到 `Container(3)` 中的 `3` 上來完成調(diào)用。也就是說，我們想把一個 functor 應(yīng)用到另一個上。
巧的是，完成這種任務(wù)的工具已經(jīng)存在了，即 `chain` 函數(shù)。我們可以先 `chain` 然后再 `map` 那個局部調(diào)用的 `add(2)`，就像這樣：
```js
Container.of(2).chain(function(two) {
return Container.of(3).map(add(two));
});
```
只不過，這種方式有一個問題，那就是 monad 的順序執(zhí)行問題：所有的代碼都只會在前一個 monad 執(zhí)行完畢之后才執(zhí)行。想想看，我們的這兩個值足夠強(qiáng)健且相互獨立，如果僅僅為了滿足 monad 的順序要求而延遲 `Container(3)` 的創(chuàng)建，我覺得是非常沒有必要的。
事實上，當(dāng)遇到這種問題的時候，要是能夠無需借助這些不必要的函數(shù)和變量，以一種簡明扼要的方式把一個 functor 的值應(yīng)用到另一個上去就好了。
## 瓶中之船
`ap` 就是這樣一種函數(shù)，能夠把一個 functor 的函數(shù)值應(yīng)用到另一個 functor 的值上。把這句話快速地說上 5 遍。
```js
Container.of(add(2)).ap(Container.of(3));
// Container(5)
// all together now
Container.of(2).map(add).ap(Container.of(3));
// Container(5)
```
這樣就大功告成了，而且代碼干凈整潔?？梢钥吹?，`Container(3)` 從嵌套的 monad 函數(shù)的牢籠中釋放了出來。需要再次強(qiáng)調(diào)的是，本例中的 `add` 是被 `map` 所局部調(diào)用（partially apply）的，所以 `add` 必須是一個 curry 函數(shù)。
可以這樣定義一個 `ap` 函數(shù)：
```js
Container.prototype.ap = function(other_container) {
return other_container.map(this.__value);
}
```
記住，`this.__value` 是一個函數(shù)，將會接收另一個 functor 作為參數(shù)，所以我們只需 `map` 它。由此我們可以得出 applicative functor 的定義：
> applicative functor 是實現(xiàn)了 `ap` 方法的 pointed functor
注意 `pointed` 這個前提，這是非常重要的一個前提，下面的例子會說明這一點。
講到這里，我已經(jīng)感受到你的疑慮了（也或者是困惑和恐懼）；心態(tài)開放點嘛，`ap` 還是很有用的。在深入理解這個概念之前，我們先來探索一個特性。
```js
F.of(x).map(f) == F.of(f).ap(F.of(x))
```
這行代碼翻譯成人類語言就是，map 一個 `f` 等價于 `ap` 一個值為 `f` 的 functor?；蛘吒玫淖g法是，你既可以把 `x` 放到容器里然后調(diào)用 `map(f)`，也可以同時讓 `f` 和 `x` 發(fā)生 lift（參看第 8 章），然后對他們調(diào)用 `ap`。這讓我們能夠以一種從左到右的方式編寫代碼：
```js
Maybe.of(add).ap(Maybe.of(2)).ap(Maybe.of(3));
// Maybe(5)
Task.of(add).ap(Task.of(2)).ap(Task.of(3));
// Task(5)
```
細(xì)心的讀者可能發(fā)現(xiàn)了，上述代碼中隱約有普通函數(shù)調(diào)用的影子。沒關(guān)系，我們稍后會學(xué)習(xí) `ap` 的 pointfree 版本；暫時先把這當(dāng)作此類代碼的推薦寫法。通過使用 `of`，每一個值都被輸送到了各個容器里的奇幻之地，就像是在另一個平行世界里，每個程序都可以是異步的或者是 null 或者隨便什么值，而且不管是什么，`ap` 都能在這個平行世界里針對這些值應(yīng)用各種各樣的函數(shù)。這就像是在一個瓶子中造船。
你注意到?jīng)]？上例中我們使用了 `Task`，這是 applicative functor 主要的用武之地?，F(xiàn)在我們來看一個更深入的例子。
## 協(xié)調(diào)與激勵
假設(shè)我們要創(chuàng)建一個旅游網(wǎng)站，既需要獲取游客目的地的列表，還需要獲取地方事件的列表。這兩個請求就是相互獨立的 api 調(diào)用。
```js
// Http.get :: String -> Task Error HTML
var renderPage = curry(function(destinations, events) { /* render page */ });
Task.of(renderPage).ap(Http.get('/destinations')).ap(Http.get('/events'))
// Task("<div>some page with dest and events</div>")
```
兩個請求將會同時立即執(zhí)行，當(dāng)兩者的響應(yīng)都返回之后，`renderPage` 就會被調(diào)用。這與 monad 版本的那種必須等待前一個任務(wù)完成才能繼續(xù)執(zhí)行后面的操作完全不同。本來我們就無需根據(jù)目的地來獲取事件，因此也就不需要依賴順序執(zhí)行。
再次強(qiáng)調(diào)，因為我們是使用局部調(diào)用的函數(shù)來達(dá)成上述結(jié)果的，所以必須要保證 `renderpage` 是 curry 函數(shù)，否則它就不會一直等到兩個 `Task` 都完成。而且如果你碰巧自己做過類似的事，那你一定會感激 `applicative functor` 這個異常簡潔的接口的。這就是那種能夠讓我們離“奇點”（singularity）更近一步的優(yōu)美代碼。
再來看另外一個例子。
```js
// 幫助函數(shù)：
// ==============
// $ :: String -> IO DOM
var $ = function(selector) {
return new IO(function(){ return document.querySelector(selector) });
}
// getVal :: String -> IO String
var getVal = compose(map(_.prop('value')), $);
// Example:
// ===============
// signIn :: String -> String -> Bool -> User
var signIn = curry(function(username, password, remember_me){ /* signing in */ })
IO.of(signIn).ap(getVal('#email')).ap(getVal('#password')).ap(IO.of(false));
// IO({id: 3, email: "gg@allin.com"})
```
`signIn` 是一個接收 3 個參數(shù)的 curry 函數(shù)，因此我們需要調(diào)用 `ap` 3 次。在每一次的 `ap` 調(diào)用中，`signIn` 就收到一個參數(shù)然后運行，直到所有的參數(shù)都傳進(jìn)來，它也就執(zhí)行完畢了。我們可以繼續(xù)擴(kuò)展這種模式，處理任意多的參數(shù)。另外，左邊兩個參數(shù)在使用 `getVal` 調(diào)用后自然而然地成為了一個 `IO`，但是最右邊的那個卻需要手動 `lift`，然后變成一個 `IO`，這是因為 `ap` 需要調(diào)用者及其參數(shù)都屬于同一類型。
## lift
（譯者注：此處原標(biāo)題是“Bro, do you even lift?”，是一流行語，發(fā)源于健身圈，指質(zhì)疑別人的健身方式和效果并顯示優(yōu)越感，后擴(kuò)散至其他領(lǐng)域。再注：作者書中用了不少此類俚語或俗語，有時并非在使用俚語的本意，就像這句，完全就是為了好玩。另，關(guān)于 lift 的概念可參看第 8 章。）
我們來試試以一種 pointfree 的方式調(diào)用 applicative functor。因為 `map` 等價于 `of/ap`，那么我們就可以定義無數(shù)個能夠 `ap` 通用函數(shù)。
```js
var liftA2 = curry(function(f, functor1, functor2) {
return functor1.map(f).ap(functor2);
});
var liftA3 = curry(function(f, functor1, functor2, functor3) {
return functor1.map(f).ap(functor2).ap(functor3);
});
//liftA4, etc
```
`liftA2` 是個奇怪的名字，聽起來像是破敗工廠里挑剔的貨運電梯，或者偽豪華汽車公司的個性車牌。不過你要是真正理解了，那么它的含義也就不證自明了：讓那些小代碼塊發(fā)生 lift，成為 applicative functor 中的一員。
剛開始我也覺得這種 2-3-4 的寫法沒什么意義，看起來又丑又沒有必要，畢竟我們可以在 JavaScript 中檢查函數(shù)的參數(shù)數(shù)量然后再動態(tài)地構(gòu)造這樣的函數(shù)。不過，局部調(diào)用（partially apply）`liftA(N)` 本身，有時也能發(fā)揮它的用處，這樣的話，參數(shù)數(shù)量就固定了。
來看看實際用例：
```js
// checkEmail :: User -> Either String Email
// checkName :: User -> Either String String
// createUser :: Email -> String -> IO User
var createUser = curry(function(email, name) { /* creating... */ });
Either.of(createUser).ap(checkEmail(user)).ap(checkName(user));
// Left("invalid email")
liftA2(createUser, checkEmail(user), checkName(user));
// Left("invalid email")
```
`createUser` 接收兩個參數(shù)，因此我們使用的是 `liftA2`。上述兩個語句是等價的，但是使用了 `liftA2` 的版本沒有提到 `Either`，這就使得它更加通用靈活，因為不必與特定的數(shù)據(jù)類型耦合在一起。
我們試試以這種方式重寫前一個例子：
```js
liftA2(add, Maybe.of(2), Maybe.of(3));
// Maybe(5)
liftA2(renderPage, Http.get('/destinations'), Http.get('/events'))
// Task("<div>some page with dest and events</div>")
liftA3(signIn, getVal('#email'), getVal('#password'), IO.of(false));
// IO({id: 3, email: "gg@allin.com"})
```
## 操作符
在 haskell、scala、PureScript 以及 swift 等語言中，開發(fā)者可以創(chuàng)建自定義的中綴操作符（infix operators），所以你能看到到這樣的語法：
```hs
-- haskell
add <$> Right 2 <*> Right 3
```
```js
// JavaScript
map(add, Right(2)).ap(Right(3))
```
`<$>` 就是 `map`（亦即 `fmap`），`<*>` 不過就是 `ap`。這樣的語法使得開發(fā)者可以以一種更自然的風(fēng)格來書寫函數(shù)式應(yīng)用，而且也能減少一些括號。
# 免費開瓶器
我們尚未對衍生函數(shù)（derived function）著墨過多。不過看到本書介紹的所有這些接口都互相依賴并遵守一些定律，那么我們就可以根據(jù)一些強(qiáng)接口來定義一些弱接口了。
比如，我們知道一個 applicative 首先是一個 functor，所以如果已經(jīng)有一個 applicative 實例的話，毫無疑問可以依此定義一個 functor。
這種完美的計算上的大和諧（computational harmony）之所以存在，是因為我們在跟一個數(shù)學(xué)“框架”打交道。哪怕是莫扎特在小時候就下載了 ableton（譯者注：一款專業(yè)的音樂制作軟件），他的鋼琴也不可能彈得更好。
前面提到過，`of/ap` 等價于 `map`，那么我們就可以利用這點來定義 `map`：
```js
// 從 of/ap 衍生出的 map
X.prototype.map = function(f) {
return this.constructor.of(f).ap(this);
}
```
monad 可以說是處在食物鏈的頂端，因此如果已經(jīng)有了一個 `chain` 函數(shù)，那么就可以免費得到 functor 和 applicative：
```js
// 從 chain 衍生出的 map
X.prototype.map = function(f) {
var m = this;
return m.chain(function(a) {
return m.constructor.of(f(a));
});
}
// 從 chain/map 衍生出的 ap
X.prototype.ap = function(other) {
return this.chain(function(f) {
return other.map(f);
});
};
```
定義一個 monad，就既能得到 applicative 也能得到 functor。這一點非常強(qiáng)大，相當(dāng)于這些“開瓶器”全都是免費的！我們甚至可以審查一個數(shù)據(jù)類型，然后自動化這個過程。
應(yīng)該要指出來的一點是，`ap` 的魅力有一部分就來自于并行的能力，所以通過 `chain` 來定義它就失去了這種優(yōu)化。即便如此，開發(fā)者在設(shè)計出最佳實現(xiàn)的過程中就能有一個立即可用的接口，也是很好的。
為啥不直接使用 monad？因為最好用合適的力量來解決合適的問題，一分不多，一分不少。這樣就能通過排除可能的功能性來做到最小化認(rèn)知負(fù)荷。因為這個原因，相比 monad，我們更傾向于使用 applicative。
向下的嵌套結(jié)構(gòu)使得 monad 擁有串行計算、變量賦值和暫緩后續(xù)執(zhí)行等獨特的能力。不過見識到 applicative 的實際用例之后，你就不必再考慮上面這些問題了。
下面，來看看理論知識。
## 定律
就像我們探索過的其他數(shù)學(xué)結(jié)構(gòu)一樣，我們在日常編碼中也依賴 applicative functor 一些有用的特性。首先，你應(yīng)該知道 applicative functor 是“組合關(guān)閉”（closed under composition）的，意味著 `ap` 永遠(yuǎn)不會改變?nèi)萜黝愋停硪粋€勝過 monad 的原因）。這并不是說我們無法擁有多種不同的作用——我們還是可以把不同的類型壓棧的，只不過我們知道它們將會在整個應(yīng)用的過程中保持不變。
下面的例子可以說明這一點：
```js
var tOfM = compose(Task.of, Maybe.of);
liftA2(_.concat, tOfM('Rainy Days and Mondays'), tOfM(' always get me down'));
// Task(Maybe(Rainy Days and Mondays always get me down))
```
你看，不必?fù)?dān)心不同的類型會混合在一起。
該去看看我們最喜歡的范疇學(xué)定律了：*同一律*（identity）。
### 同一律（identity）
```js
// 同一律
A.of(id).ap(v) == v
```
是的，對一個 functor 應(yīng)用 `id` 函數(shù)不會改變 `v` 里的值。比如：
```js
var v = Identity.of("Pillow Pets");
Identity.of(id).ap(v) == v
```
`Identity.of(id)` 的“無用性”讓我不禁莞爾。這里有意思的一點是，就像我們之前證明了的，`of/ap` 等價于 `map`，因此這個同一律遵循的是 functor 的同一律：`map(id) == id`。
使用這些定律的優(yōu)美之處在于，就像一個富有激情的幼兒園健身教練讓所有的小朋友都能愉快地一塊玩耍一樣，它們能夠強(qiáng)迫所有的接口都能完美結(jié)合。
### 同態(tài)（homomorphism）
```js
// 同態(tài)
A.of(f).ap(A.of(x)) == A.of(f(x))
```
*同態(tài)*就是一個能夠保持結(jié)構(gòu)的映射（structure preserving map）。實際上，functor 就是一個在不同范疇間的同態(tài)，因為 functor 在經(jīng)過映射之后保持了原始范疇的結(jié)構(gòu)。
事實上，我們不過是把普通的函數(shù)和值放進(jìn)了一個容器，然后在里面進(jìn)行各種計算。所以，不管是把所有的計算都放在容器里（等式左邊），還是先在外面進(jìn)行計算然后再放到容器里（等式右邊），其結(jié)果都是一樣的。
一個簡單例子：
```js
Either.of(_.toUpper).ap(Either.of("oreos")) == Either.of(_.toUpper("oreos"))
```
### 互換（interchange）
互換（interchange）表明的是選擇讓函數(shù)在 `ap` 的左邊還是右邊發(fā)生 lift 是無關(guān)緊要的。
```js
// 互換
v.ap(A.of(x)) == A.of(function(f) { return f(x) }).ap(v)
```
這里有個例子：
```js
var v = Task.of(_.reverse);
var x = 'Sparklehorse';
v.ap(Task.of(x)) == Task.of(function(f) { return f(x) }).ap(v)
```
### 組合（composition）
最后是組合。組合不過是在檢查標(biāo)準(zhǔn)的函數(shù)組合是否適用于容器內(nèi)部的函數(shù)調(diào)用。
```js
// 組合
A.of(compose).ap(u).ap(v).ap(w) == u.ap(v.ap(w));
```
```js
var u = IO.of(_.toUpper);
var v = IO.of(_.concat("& beyond"));
var w = IO.of("blood bath ");
IO.of(_.compose).ap(u).ap(v).ap(w) == u.ap(v.ap(w))
```
## 總結(jié)
處理多個 functor 作為參數(shù)的情況，是 applicative functor 一個非常好的應(yīng)用場景。借助 applicative functor，我們能夠在 functor 的世界里調(diào)用函數(shù)。盡管已經(jīng)可以通過 monad 達(dá)到這個目的，但在不需要 monad 的特定功能的時候，我們還是更傾向于使用 applicative functor。
至此我們已經(jīng)基本介紹完容器的 api 了，我們學(xué)會了如何對函數(shù)調(diào)用 `map`、`chain` 和 `ap`。下一章，我們將學(xué)習(xí)如何更好地處理多個 functor，以及如何以一種原則性的方式拆解它們。
[Chapter 11: Traversable/Foldable Functors](ch11.md)
## 練習(xí)
```js
require('./support');
var Task = require('data.task');
var _ = require('ramda');
// 模擬瀏覽器的 localStorage 對象
var localStorage = {};
// 練習(xí) 1
// ==========
// 寫一個函數(shù)，使用 Maybe 和 ap() 實現(xiàn)讓兩個可能是 null 的數(shù)值相加。
// ex1 :: Number -> Number -> Maybe Number
var ex1 = function(x, y) {
};
// 練習(xí) 2
// ==========
// 寫一個函數(shù)，接收兩個 Maybe 為參數(shù)，讓它們相加。使用 liftA2 代替 ap()。
// ex2 :: Maybe Number -> Maybe Number -> Maybe Number
var ex2 = undefined;
// 練習(xí) 3
// ==========
// 運行 getPost(n) 和 getComments(n)，兩者都運行完畢后執(zhí)行渲染頁面的操作。（參數(shù) n 可以是任意值）。
var makeComments = _.reduce(function(acc, c){ return acc+"<li>"+c+"</li>" }, "");
var render = _.curry(function(p, cs) { return "<div>"+p.title+"</div>"+makeComments(cs); });
// ex3 :: Task Error HTML
var ex3 = undefined;
// 練習(xí) 4
// ==========
// 寫一個 IO，從緩存中讀取 player1 和 player2，然后開始游戲。
localStorage.player1 = "toby";
localStorage.player2 = "sally";
var getCache = function(x) {
return new IO(function() { return localStorage[x]; });
}
var game = _.curry(function(p1, p2) { return p1 + ' vs ' + p2; });
// ex4 :: IO String
var ex4 = undefined;
// 幫助函數(shù)
// =====================
function getPost(i) {
return new Task(function (rej, res) {
setTimeout(function () { res({ id: i, title: 'Love them futures' }); }, 300);
});
}
function getComments(i) {
return new Task(function (rej, res) {
setTimeout(function () {
res(["This book should be illegal", "Monads are like space burritos"]);
}, 300);
});
}
```
