functor

functor是能够被map over的容器范例。

关于这句话比较难明白的是,什么是map over?

(a -> b) -> f a -> f b 意义就是说一个a到b的映照,在接收a的functor以后,返回一个b的functor，下面是map over运用示例，能够结合著明白这句话。

const f= x => x.split("").reverse().join("");
const rs='olleh';
const b=f(rs);  
console.log(b); //hello


function JSDT(val) {
    this._val=val;
}
JSDT.prototype.map=function (f) {
    return new JSDT(f(this._val));
};
JSDT.of=function (val) {
    return new JSDT(val);
}
const fa=JSDT.of(rs);
const fb=fa.map(f);  
console.log(fb);   //JSDT {_val: "hello"}

申明 完成了map的container是Functor的实例(JSDT),map是将函数运用到container内部的要领。

functor出自领域论(Category Theory),数学的一个分支,满足一些定律。

• fa.map(x => x) === fa;
• fa.map(x => f(g(x))) === fa.map(g).map(f);

申明 关于这两个定律下面有一个很好的明白例子

var a=[1,2,3].map(x => x);
console.log(a);  //[ 1, 2, 3 ]

const f= x => x+2;
const g= x => x*2;
var b1=[1,2,3].map(x => f(g(x)));
var b2=[1,2,3].map(g).map(f);
console.log(b1.toString()===b2.toString()); //true

Applicative Functor

Applicative实质是Functor的一种,能够将一个含有函数的容器运用到另一个容器中的值上。

JSDT.prototype.ap=function (container) {
    return container.map(this._val);
}
const f=JSDT.of(x => x+2);
let fy=f.ap(JSDT.of(3));
console.log(fy);  //JSDT { _val: 5 }

申明 Applicative的特征就是多了一层ap,示例中JSDT实例f中,this._val是笼统函数单位,能够运用到另一个匿名实例上。

applicative满足的定律

• a.of(x => x).ap(val) === val;
• a.of(f).op(a.of(x)) === a.of(f(x));
• u.ap(a.of(y)) === a.of(f => f(y)).ap(u);

Monad

Monad是一种特别的Functor,能够Flat(摊平)map的效果。

function Nothing() {
}
Nothing.prototype.map=function () {
    return this;
}
const nothing=new Nothing();
JSDT.prototype.flat=function () {
    return this._val;
}
JSDT.prototype.flatMap=function (f) {
    return this.map(f).flat();
}
let fm=JSDT.of({val:0}).
    flatMap(x => {
    if(x) return JSDT.of(x.val);
    else return nothing;
})
    .map(x => x+1)
    .map( x => 2/x);
console.log(fm);  //JSDT { _val: 2 }

申明 假如用一般map,第一层非常时,会一连实行,经由过程monad的体式格局能够在非常发作时,不管怎样map末了照样它自己,从而能够在非常发作时防止不必要的毛病实行。

总结

monadic编程主要且广泛,典范的一种运用就是promise、还能够合营别的reactive编程框架运用,明白道理能协助我们更好的运用。在深切过程当中发明种种八怪七喇的名词,但耐烦去剖析和思索,也不难明白。