摘要：前面我們已經(jīng)知道如何書寫函數(shù)式的程序了，但是我們還沒提到控制流異常處理異步操作和狀態(tài)呢容器容器為函數(shù)式編程里普通的變量對象函數(shù)提供了一層極其強大的外衣，賦予了它們一些很驚艷的特性按照我們的慣例，先從最簡單的容器入手。

如果你前面都看完了跟到了這里，我只能說你很棒棒，不過我不得不說，這才剛剛開始。前面我們已經(jīng)知道如何書寫函數(shù)式的程序了，但是我們還沒提到控制流（control flow）、異常處理（error handling）、異步操作（asynchronous actions）和狀態(tài)（state）呢？

容器為函數(shù)式編程里普通的變量、對象、函數(shù)提供了一層極其強大的外衣，賦予了它們一些很驚艷的特性
按照我們的慣例，先從最簡單的容器入手。

var Container = function(x) {
  this.__value = x;
}

Container.of = function(x) { return new Container(x); };

試著執(zhí)行以下Container.of(3)，看看輸出的值。
jQuery $(...) 返回的對象并不是一個原生的 DOM 對象，而是對于原生對象的一種封裝，某種意義上就是一個“容器”。
我們接著添加一個map方法

Container.prototype.map = function(f){
  return Container.of(f(this.__value))
}

Container.of(3)
    .map(x => x + 1)                //=> Container(4)
    .map(x => "Result is " + x);    //=> Container("Result is 4")

這個跟前面我們提到的數(shù)組操作的map方法非常類似，數(shù)組的map方法返回一個新的數(shù)組，Container的map方法返回一個新的Container。

上面的這個具有map方法的容器就是我們接下來要引出來的函子。

Functor（函子）是實現(xiàn)了 map 并遵守一些特定規(guī)則的容器類型。

Functor 是一個對于函數(shù)調用的抽象，我們賦予容器自己去調用函數(shù)的能力。當 map 一個函數(shù)時，我們讓容器自己來運行這個函數(shù)，這樣容器就可以自由地選擇何時何地如何操作這個函數(shù)，以致于擁有惰性求值、錯誤處理、異步調用等等非常牛掰的特性
接著我們看看牛掰的Functor能為我們做什么

var Maybe = function(x) {
  this.__value = x;
}

Maybe.of = function(x) {
  return new Maybe(x);
}

Maybe.prototype.isNothing = function() {
  return (this.__value === null || this.__value === undefined);
}

Maybe.prototype.map = function(f) {
  return this.isNothing() ? Maybe.of(null) : Maybe.of(f(this.__value));
}

Maybe.of("Malkovich Malkovich").map(match(/a/ig));
//=> Maybe(["a", "a"])

Maybe.of(null).map(match(/a/ig));
//=> Maybe(null)，代碼并沒有報錯，我們在對函數(shù)調用時，檢查了函數(shù)是否為空

我們?nèi)绻幌胍恢?map .map, 可以用柯里化函數(shù)對上面的代碼稍微改進一下

var map = curry((f, any_functor_at_all) => any_functor_at_all.map(f));

錯誤處理

var Left = function(x) {
  this.__value = x;
}
var Right = function(x) {
  this.__value = x;
}

Left.of = function(x) {
  return new Left(x);
}
Right.of = function(x) {
  return new Right(x);
}

Left.prototype.map = function(f) {
  return this;
}
Right.prototype.map = function(f) {
  return Right.of(f(this.__value));
}

var getAge = user => user.age ? Right.of(user.age) : Left.of("ERROR!");

getAge({name: "stark", age: "21"}).map(age => "Age is " + age);

getAge({name: "stark"}).map(age => "Age is " + age);

//Left 會終端機鏈式調用

最后來看下我們不得不做的IO操作

let readLocalStorage = () => {
    return window.localStorage;
}

機智的改造成純函數(shù)

let readLocalStorage = () => {
    return () => {window.localStorage};
}

然而并沒有什么軟用

var IO = function(f) {
  this.__value = f;
}

IO.of = function(x) {
  return new IO(() => x);
}

IO.prototype.map = function(f) {
  return new IO(_.compose(f, this.__value));
}

var io_window = new IO(function(){ return window; });

io_window.map(function(win){ return win.innerWidth });

io_window.map(_.prop("location")).map(_.prop("href")).map(split("/"));


var $ = function(selector) {
  return new IO(function(){ return document.querySelectorAll(selector); });
}

$("#myDiv").map(head).map(function(div){ return div.innerHTML; });