函子

一、为什么学函子
为了把函数式编程中产生的副作用控制在可控的范围内、异常处理、异步操作等
二、什么是函子
容器：包含值以及处理这个值的函数
函子：是一个特殊的容器，可以把函子想象成一个盒子，盒子里有一个值，并且这个盒子对外要公布一个方法（map）,map接收一个参数（对值进行处理的函数）

// 一个容器，包裹一个值
class Container {
// of 静态方法，可以省略 new 关键字创建对象
static of (value) {
return new Container(value)
}
constructor (value) {
this._value = value
}
// map 方法，传入变形关系，将容器里的每一个值映射到另一个容器
map (fn) {
return Container.of(fn(this._value))
}
}
// 测试
Container.of(3)
.map(x => x + 2)
.map(x => x * x)

总结：
函数式编程的运算不直接操作值，而是由函子完成
函子就是一个实现了 map 契约的对象
我们可以把函子想象成一个盒子，这个盒子里封装了一个值
想要处理盒子中的值，我们需要给盒子的 map 方法传递一个处理值的函数（纯函数），由这
个函数来对值进行处理
最终 map 方法返回一个包含新值的盒子（函子）
问题：
在 Functor 中如果我们传入 null 或 undefined

// 值如果不小心传入了空值(副作用)
Container.of(null)
.map(x => x.toUpperCase())
// TypeError: Cannot read property 'toUpperCase' of null

MayBe函子
我们在编程的过程中可能会遇到很多错误，需要对这些错误做相应的处理
MayBe 函子的作用就是可以对外部的空值情况做处理（控制副作用在允许的范围）

class MayBe {
static of (value) {
return new MayBe(value)
}
constructor (value) {
this._value = value
}
// 如果对空值变形的话直接返回 值为 null 的函子
map (fn) {
return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
}
isNothing () {
return this._value === null || this._value === undefined
}
}
// 传入具体值
MayBe.of('Hello World')
.map(x => x.toUpperCase())
// 传入 null 的情况
MayBe.of(null)
.map(x => x.toUpperCase())
// => MayBe { _value: null }

在 MayBe 函子中，我们很难确认是哪一步产生的空值问题，如下例：

MayBe.of('hello world')
.map(x => x.toUpperCase())
.map(x => null)
.map(x => x.split(' '))
// => MayBe { _value: null }

Either 函子
Either 两者中的任何一个，类似于 if…else…的处理
异常会让函数变的不纯，Either 函子可以用来做异常处理

class Left {
static of (value) {
return new Left(value)
}
constructor (value) {
this._value = value
}
map (fn) {
return this
}
}

class Right {
static of (value) {
return new Right(value)
}
constructor (value) {
this._value = value
}
map(fn) {
return Right.of(fn(this._value))
}
}

Either 用来处理异常

function parseJSON(json) {
try {
return Right.of(JSON.parse(json));
} catch (e) {
return Left.of({ error: e.message});
}
}
let r = parseJSON('{ "name": "zs" }')
.map(x => x.name.toUpperCase())
console.log(r)