摘要：但有時(shí)候，所有的鳥都會(huì)想要停在同一邊，皮爾斯就失去了平衡，就會(huì)讓他從鋼索上掉下去。我們這邊假設(shè)兩邊的鳥差異在三個(gè)之內(nèi)的時(shí)候，皮爾斯仍能保持平衡。

Monad 這個(gè)概念好難解釋, 你可以理解為一個(gè) Lazy 或者是狀態(tài)未知的盒子. 聽起來(lái)像是薛定諤貓(估計(jì)點(diǎn)進(jìn)去你會(huì)更暈了). 其實(shí)就是的, 在你打開這個(gè)盒子之前, 你是不知道里面的貓?zhí)幵谀欠N狀態(tài).

Monad 這個(gè)黑盒子, 里面到底賣的神馬藥,我們要打開喝了才知道.

等等, 不是說(shuō)好要解釋 Either 的嗎, 嗯嗯, 這里就是在解釋 Either. 上節(jié)說(shuō) Either 是一個(gè) Functor, 可以被 fmap over. 怎么這里又說(shuō)道黑盒子了? 好吧, Monad 其實(shí)也是 Functor. 還記得我說(shuō)的 Functor 其實(shí)是一個(gè)帶 context 的盒子嗎. 而 fmap 使得往盒子里應(yīng)用函數(shù)變換成為了可能.

先來(lái)看看 Either 這種類型會(huì)干什么事情. Either 表示要不是左邊就是右邊的值, 因此我們可以用它來(lái)表示薛定諤貓, 要不是活著, 要不死了. Either 還有個(gè)方法:
either

(a -> c) -> (b -> c) -> Either a b -> c

想必你已經(jīng)對(duì)箭頭->非常熟了吧.如果前面幾章你都跳過(guò)了,我再翻譯下好了. 這里表示接收函數(shù)a->c和函數(shù) b->c, 再接收一個(gè) Either, 如果 Either 的值在左邊,則使用函數(shù)映射 a->c, 若值在右邊,則應(yīng)用第二個(gè)函數(shù)映射 b->c.

作為 Monad, 它還必須具備一個(gè)方法 ">>="(這個(gè)符號(hào)好眼熟的說(shuō), 看看 haskell 的 logo, 你就知道 Monad 是有多重要), 也就是 bind 方法.

bind 方法的意思很簡(jiǎn)單, 就是給這個(gè)盒子加一個(gè)操作, 比如往盒子在加放射性原子,如果貓活著,就是綠巨貓, 如果貓是死的,那就是綠巨死貓.

Left("cat").bind(cat => "hulk"+cat)
// => Left "hulkcat"
Right("deadcat").bind(cat => "hulk" + cat)
// => Right "hulkdeadcat"

這有個(gè)毛用啊. 表急... 來(lái)看個(gè)經(jīng)典例子

皮爾斯決定要辭掉他的工作改行試著走鋼索。他對(duì)走鋼索蠻在行的，不過(guò)仍有個(gè)小問(wèn)題。就是鳥會(huì)停在他拿的平衡竿上。他們會(huì)飛過(guò)來(lái)停一小會(huì)兒，然后再飛走。這樣的情況在兩邊的鳥的數(shù)量一樣時(shí)并不是個(gè)太大的問(wèn)題。但有時(shí)候，所有的鳥都會(huì)想要停在同一邊，皮爾斯就失去了平衡，就會(huì)讓他從鋼索上掉下去。

我們這邊假設(shè)兩邊的鳥差異在三個(gè)之內(nèi)的時(shí)候，皮爾斯仍能保持平衡。

首先看看不用 Monad 怎么解

eweda.installTo(this);
var landLeft = eweda.curry(function(n, pole){
    return [pole[0]+n, pole[1]];
});
var landRight = eweda.curry(function(n, pole){
    return landLeft(n, eweda.reverse(pole));
});
var result = eweda.pipe(landLeft(1), landRight(1), landLeft(2))([0,0]);
console.log(result);
// => [3, 1]

還差一個(gè)判斷皮爾斯是否掉下來(lái)的操作.

var landLeft = eweda.curry(function(n, pole){
    if(pole==="dead") return pole;
    if(Math.abs(pole[0]-pole[1]) > 3)
      return "dead";
    return [pole[0]+n, pole[1]];
});
var landRight = eweda.curry(function(n, pole){
    if(pole==="dead") return pole;
    return landLeft(n, eweda.reverse(pole));
});
var result = eweda.pipe(landLeft(10), landRight(1), landRight(8))([0,0]);
console.log(result);
// => dead

完整代碼

我們先把皮爾斯放進(jìn) Either 盒子里, 這樣皮爾斯的狀態(tài)只有打開 Either 才能看見. 假設(shè) Either Right 是活著, Left 的話皮爾斯掛了.

var land = eweda.curry(function(lr, n, pole){
    pole[lr] = pole[lr] + n;
    if(Math.abs(pole[0]-pole[1]) > 3) {
      return new Left("dead when land " + n + " became " + pole);
    }
    return new Right(pole);
});

var landLeft = land(0)
var landRight = land(1);

現(xiàn)在落鳥后會(huì)返回一個(gè) Either, 要不活著, 要不掛了. 打開盒子的函數(shù)可以是這樣的

var stillAlive = function(x){
    console.log(x)
}
var dead = function(x){
    console.log("皮爾斯" + x);
}
either(dead, stillAlive, landLeft(2, [0,0]))

好吧, 好像有一點(diǎn)點(diǎn)像了, 但是這只落了一次鳥, 如果我要落好幾次呢. 這就需要實(shí)現(xiàn) Either 的 >>= bind 方法了, 如果你還記得前面實(shí)現(xiàn)的 Functor, 這里非常像 :

var Monad = function(type, defs) {
  for (name in defs){
    type.prototype[name] = defs[name];
  }
  return type;
};
function Left(value){
  this.value = value
}
function Right(value){
  this.value=value;
}

Monad(Right, {
  bind:function(fn){
    return fn(this.value)
  }
})

Monad(Left, {
  bind: function(fn){
    return this;
  }
})

哦, 對(duì)了, either:

either = function(left, right, either){
    if(either.constructor.name === "Right")
        return right(either.value)
    else
        return left(either.value)
}

我們來(lái)試試工作不工作.

var walkInLine = new Right([0,0]);
eitherDeadOrNot = walkInLine.bind(landLeft(2))
    .bind(landRight(5))
either(dead, stillAlive, eitherDeadOrNot)
// => [2,5]
eitherDeadOrNot = walkInLine.bind(landLeft(2))
  .bind(landRight(5))
  .bind(landLeft(3))
  .bind(landLeft(10)
  .bind(landRight(10)))

either(dead, stillAlive, eitherDeadOrNot)
// => "皮爾斯dead when land 10 became 15,5"

完整代碼

我們來(lái)總結(jié)下兩種做法有什么區(qū)別:

一般做法每次都會(huì)檢查查爾斯掛了沒(méi)掛, 也就是重復(fù)獲得之前操作的 context

Monad 不對(duì)異常做處理, 只是不停地往盒子里加操作. 你可以看到對(duì)錯(cuò)誤的處理推到了最后取值的 either.

Monad 互相傳遞的只是盒子, 而一般寫法會(huì)把異常往下傳如"dead", 這樣導(dǎo)致后面的操作都得先判斷這個(gè)異常.

comment 由于是用 JavaScript, pole 不限定類型, 所以這里單純的用字符串代表 pole 的異常狀態(tài). 但如果換成強(qiáng)類型的 Java, 可能實(shí)現(xiàn)就沒(méi)這么簡(jiǎn)單了.

看來(lái)已經(jīng)優(yōu)勢(shì)已經(jīng)逐步明顯了呢, Monad 里面保留了值的 context, 也就是我們對(duì)這個(gè) Monad 可以集中在多帶帶的本次如何操作value, 而不用關(guān)心 context.

還有一個(gè) Monad 叫做 Maybe, 實(shí)際上皮爾斯的

你知道 ES6有個(gè)新的 類型 Promise 嗎, 如果不知道, 想必也聽過(guò) jQuery 的 $.ajax吧, 但如果你沒(méi)聽過(guò) promise, 說(shuō)明你沒(méi)有認(rèn)真看過(guò)他的返回值:

var aPromise = $.ajax({
    url: "https://api.github.com/users/jcouyang/gists"
    dataType: "jsonp"
    })
aPromise /***
=> Object { state: .Deferred/r.state(),
    always: .Deferred/r.always(),
    then: .Deferred/r.then(),
    promise: .Deferred/r.promise(),
    pipe: .Deferred/r.then(),
    done: b.Callbacks/p.add(),
    fail: b.Callbacks/p.add(),
    progress: b.Callbacks/p.add() }
***/

我們看到返回了好多Deferred類型的玩意, 我們來(lái)試試這玩意有什么用

anotherPromise = aPromise.then(_ => _.data.forEach(y=> console.log(y.description)))
/* =>
Object { state: .Deferred/r.state(),
    always: .Deferred/r.always(),
    then: .Deferred/r.then(),
    promise: .Deferred/r.promise(),
    pipe: .Deferred/r.then(),
    done: b.Callbacks/p.add(),
    fail: b.Callbacks/p.add(),
    progress: b.Callbacks/p.add() }

"connect cisco anyconnect in terminal"
"為什么要柯里化（curry）"
"批量獲取人人影視下載鏈接"
......
*/

看見沒(méi)有, 他又返回了同樣一個(gè)東西, 而且傳給 then 的函數(shù)可以操作這個(gè)對(duì)象里面的值. 這個(gè)對(duì)象其實(shí)就是 Promise 了. 為什么說(shuō)這是 Monad 呢, 來(lái)試試再寫一次走鋼絲:

這里我們用的是 ES6 的 Promise, 而不用 jQuery Defered, 記得用 firefox 哦. 另外 eweda 可以這樣裝

var ewd = document.createElement("script"); ewd.type = "text/javascript"; ewd.async = true;
            ewd.src = "https://rawgit.com/CrossEye/eweda/master/eweda.js";
(document.getElementsByTagName("head")[0] || document.getElementsByTagName("body")[0]).appendChild(ewd);

eweda.installTo(this); //安裝到 window 上

var land = curry(function(lr, n, pole){
    pole[lr] = pole[lr] + n;
    if(Math.abs(pole[0]-pole[1]) > 3) {
      return new Promise((resovle,reject)=>reject("dead when land " + n + " became " + pole));
    }
    return new Promise((resolve,reject)=>resolve(pole));
});

var landLeft = land(0)
var landRight = land(1);

Promise.all([0,0])
.then(landLeft(2), _=>_)
.then(landRight(3), _=>_) // => Array [ 2, 3 ]
.then(landLeft(10), _=>_)
.then(landRight(10), _=>_)
.then(_=>console.log(_),_=>console.log(_))
// => "dead when land 10 became 12,3"

這下是不承認(rèn) Promise 就是 Monad 了. 原來(lái)我們?cè)缫言谑褂眠@個(gè)神秘的 Monad, 再想想 Promise,也沒(méi)有那么抽象和神秘了.

ref： Functional JavaScript 第四章