任务1 函数式编程范式 - 函子 - 《part1 JavaScript 深度解析》

概念
Maybe函子
IO函子

函子的作用是把函数式编程的副作用控制在可控的范围内。

概念

容器：包含值和值的变形关系(这个变形关系就是函数)
函子：是一个特殊的容器，通过一个普通的对象来实现，该对象具有 map 方法，map 方法可以运
行一个函数对值进行处理(变形关系)

class Container {
  static of (value) {
    return new Container(value)
  } //of函数的作用是使得不用每次都new一个Container，让代码看起来不像面向对象编程。
  //构造函数
  constructor (value) {
    this._value = value
  }
  map (fn) {
    return Container.of(fn(this._value))
  }
}

这样，我们不用去关心中间过程的结果，如果需要对一个值进行处理，那么不断去调用map，把中间过程的函数传入进去即可。

 let r = Container.of(5)
           .map(x => x + 2)
           .map(x => x * x)

Maybe函子

当函子处理值的时候，出现中间值是null或者undefined的情况，程序会抛出错误，这就是外部传参带来的副作用。为了控制这种副作用，我们定义一个Maybe函子，它是能处理值可能为空的情况的函子。

// MayBe 函子
class MayBe {
  static of (value) {
    return new MayBe(value)
  }
  constructor (value) {
    this._value = value
  }
  map (fn) {
    return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value)) //如果_value是空值，直接返回一个_value为空的函子，如果不是空，再调用fn处理数据。
  }
//处理空值的方法
  isNothing () {
    return this._value === null || this._value === undefined
  }
}

Either 函子

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

上面的代码可以打印出一个值为null的Maybe函子，但是我们无法知道是哪一个地方产生了null值。所以我们使用Either函子来解决。Either函子有两个函子，left和right，当fn正常执行，返回right函子，当出现异常，返回left函子。

// 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))
  }
}
//例子
function parseJSON (str) {
  try {
    return Right.of(JSON.parse(str))
  } catch (e) {
    return Left.of({ error: e.message })
  }
}

IO函子

IO 函子中的 _value 是一个函数，这里是把函数作为值来处理。
IO 函子可以把不纯的动作存储到 _value 这个函数中，延迟执行这个不纯的操作(惰性执行)，让当前的操作变得纯。
把不纯的操作，如读取文件，交给调用者来处理。 ```javascript // IO 函子 const fp = require(‘lodash/fp’)

class IO { static of (value) { return new IO(function () { return value }) }

constructor (fn) { this._value = fn }

map (fn) { return new IO(fp.flowRight(fn, this._value)) //map是要把当前函子的_value函数和传入的fn函数组合起来 } }

// 调用 let r = IO.of(process).map(p => p.execPath) //process->进程 // console.log(r) console.log(r._value())

<a name="DwYXy"></a>
## Monad函子
```javascript
// IO 函子的问题
const fs = require('fs')
const fp = require('lodash/fp')
class IO {
  static of (value) {
    return new IO(function () {
      return value
    })
  }
  constructor (fn) {
    this._value = fn
  }
  map (fn) {
    return new IO(fp.flowRight(fn, this._value))
  }
}
let readFile = function (filename) {
  return new IO(function () {
    return fs.readFileSync(filename, 'utf-8')
  })
}
let print = function (x) {
  return new IO(function () {
    console.log(x)
    return x
  })
}
let cat = fp.flowRight(print, readFile)
// IO(IO(x))
let r = cat('package.json')._value()._value()
console.log(r)

上面的代码演示了IO函子的嵌套，当IO函子嵌套，我们如果想拿到最终的值，要像上面那样不断地调用_value()。这样风格看起来比较奇怪。所以为了解决函子嵌套的问题，我们引入Monad函子。<br />

Monad 函子是可以变扁的 Pointed 函子，IO(IO(x)) 。一个函子如果具有 join 和 of 两个方法并遵守一些定律就是一个Monad函子。以下是IO Monad函子：

// IO Monad
const fs = require('fs')
const fp = require('lodash/fp')
class IO {
  static of (value) {
    return new IO(function () {
      return value
    })
  }
  constructor (fn) {
    this._value = fn
  }
    //当返回的是值，用map
  map (fn) {
    return new IO(fp.flowRight(fn, this._value))
  }
  //在Monad里传递的函数fn，最终会返回一个函子
  join () {
    return this._value()
  }
    //当返回的是一个函子，用flapMap
  flatMap (fn) {
    return this.map(fn).join()
  }
}
//演示一个读取文件并打印的例子
let readFile = function (filename) {
  return new IO(function () {
    return fs.readFileSync(filename, 'utf-8')
  })
}
let print = function (x) {
  return new IO(function () {
    console.log(x)
    return x
  })
}
let r = readFile('package.json')
          // .map(x => x.toUpperCase())
          .map(fp.toUpper)
          .flatMap(print)
          .join()
console.log(r)