关于javascript:函数式编程五-函子

6次阅读

共计 8928 个字符，预计需要花费 23 分钟才能阅读完成。

Functor

为什么要学函子？
什么是 Functor
了解 Functor
总结
MyBe 函子
Either 函子
IO 函子

Task 函子（异步执行）

*  folktale 的装置
* folktale 中的 curry 函数
* folktale 中的 compose 函数
* Task 函子异步执行
* 案例

Pointed 函子

Monad 函子（单子）

* IO 函子的嵌套问题
* 什么是 Monad 函子
* 实现一个 Monad 函子
* Monad 函子小结
    * 什么是 Monad？* 什么时候应用 Monad?

【函数式编程总体设计】

之前讲了函数的前置常识函数式编程（一）—— 前置常识

还有纯函数的常识函数式编程（二）—— 纯函数

柯里化函数式编程（三）—— 柯里化

函数组合函数式编程（四）——函数组合

函子 (representative functor) 是领域论里的概念，指从任意领域到汇合领域的一种非凡函子。
咱们没有方法防止副作用，然而咱们尽可能的将副作用管制在可控的范畴内，咱们能够通过函子去解决副作用，咱们也能够通过函子去解决异样，异步操作等。

容器：蕴含值和值的变形关系(这个变形关系就是函数)
函子：是一个非凡的容器，通过一个一般的对象来实现，该对象具备 map 办法，map 办法能够运行一个函数对值进行解决(变形关系)

class Container {constructor (value) {
    // 这个函子的值是保留在外部的，不对外颁布
    // _下划线的成员都是公有成员，内部无法访问，值是初始化的传的参数
    this._value = value
  }
  
  // 有一个对外的办法 map，接管一个函数（纯函数），来解决这个值
  map (fn) {
    // 返回一个新的函子，把 fn 解决的值返回给函子，由新的函子来保留
    return new Container(fn(this._value))
  }
}

// 创立一个函子的对象
let r = new Container(5)
  .map(x => x + 1) // 6
  .map(x => x ** 2) // 36

// 返回了一个 container 函子对象，外面有值是 36，不对外颁布
console.log(r) //Container {_value: 36}

下面还是面向对象的编程思维，要批改成函数式编程的思维，须要防止应用 new

class Container {
  // 应用类的静态方法，of 代替了 new Container 的作用
  static of (value) {return new Container(value)
  }
  constructor (value) {this._value = value}
  
  map (fn) {return Container.of(fn(this._value))
  }
}

const r = Container.of(5)
            .map(x=>x+2) // 7
            .map(x=> x**2) // 49

console.log(r) // Container {_value: 49}

函数式编程的运算不间接操作值，而是由函子实现
函子就是一个实现了 map 契约的对象
咱们能够把函子设想成一个盒子，这个盒子里封装了一个值
想要解决盒子中的值，咱们须要给盒子的 map 办法传递一个解决值的函数（纯函数），由这个函数来对值进行解决
最终 map 办法返回一个蕴含新值的盒子（函子）

遗留问题：如果 value 是 null undefined，怎么办？

Container.of(null)
  .map(x=>x.toUpper) // 报错，使得函数不纯

上面会有好几种函子，解决不同的问题

MayBe 函子的作用就是能够对外部的空值状况做解决（管制副作用在容许的范畴）

class MayBe {static of (value) {return new MayBe(value)
  }
  constructor (value) {this._value = value}

  map(fn) {
    // 判断一下 value 的值是不是 null 和 undefined，如果是就返回一个 value 为 null 的函子，如果不是就执行函数
    return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
  }

 // 定义一个判断是不是 null 或者 undefined 的函数，返回 true/false
  isNothing() {return this._value === null || this._value === undefined}
}

const r = MayBe.of('hello world')
  .map(x => x.toUpperCase())

console.log(r) //MayBe {_value: 'HELLO WORLD'}


// 如果输出的是 null，是不会报错的
const rnull = MayBe.of(null)
  .map(x => x.toUpperCase())
console.log(rnull) //MayBe {_value: null}

然而这里有一个问题就是，如果 map 两头有好几步，最初返回是 null，并不知道是哪一个步骤返回的。解决这个问题，须要看下一个函子。

Either 两者中的任何一个，相似于 if…else… 的解决
当呈现问题的时候，Either 函子会给出提醒的无效信息，
异样会让函数变的不纯，Either 函子能够用来做异样解决

// 因为是二选一，所以要定义 left 和 right 两个函子

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))
  }
}

let r1 = Right.of(12).map(x => x + 2)
let r2 = Left.of(12).map(x => x + 2)
console.log(r1) // Right {_value: 14}
console.log(r2) // Left {_value: 12}
// 为什么后果会不一样？因为 Left 返回的是以后对象，并没有应用 fn 函数

// 那么这里如何解决异样呢？// 咱们定义一个字符串转换成对象的函数
function parseJSON(str) {
  // 对于可能出错的环节应用 try-catch
  // 失常状况应用 Right 函子
  try{return Right.of(JSON.parse(str))
  }catch (e) {
  // 谬误之后应用 Left 函子，并返回错误信息
    return Left.of({error: e.message})
  }
}

let rE = parseJSON('{name:xm}')
console.log(rE) // Left {_value: { error: 'Unexpected token n in JSON at position 1'} }
let rR = parseJSON('{"name":"xm"}')
console.log(rR) // Right {_value: { name: 'xm'} }

console.log(rR.map(x => x.name.toUpperCase())) // Right {_value: 'XM'}

IO 就是输入输出，IO 函子中的 _value 是一个函数，这里是把函数作为值来解决
IO 函子能够把不纯的动作存储到 _value 中，提早执行这个不纯的操作(惰性执行)，包装以后的操

作

把不纯的操作交给调用者来解决

因为 IO 函数须要用到组合函数，所以须要提前装置 Lodash

npm init -y

npm i lodash

const fp = require('lodash/fp')

class IO {
  // of 办法疾速创立 IO，要一个值返回一个函数，未来须要值的时候再调用函数
  static of(value) {return new IO(() => value)
  }
  // 传入的是一个函数
  constructor (fn) {this._value = fn}

  map(fn) {
    // 这里用的是 new 一个新的构造函数，是为了把以后_value 的函数和 map 传入的 fn 进行组合成新的函数
    return new IO(fp.flowRight(fn, this._value))
  }
}


// test
// node 执行环境能够传一个 process 对象（过程）// 调用 of 的时候把以后取值的过程包装到函数外面，再在须要的时候再获取 process
const r = IO.of(process)
  // map 须要传入一个函数，函数须要接管一个参数，这个参数就是 of 中传递的参数 process
  // 返回一下 process 中的 execPath 属性即以后 node 过程的执行门路
  .map(p => p.execPath)
console.log(r) // IO {_value: [Function] }


// 下面只是组合函数，如果须要调用就执行上面
console.log(r._value()) // C:\Program Files\nodejs\node.exe

函子能够管制副作用，还能够解决异步工作，为了防止天堂之门。
异步工作的实现过于简单，咱们应用 folktale 中的 Task 来演示
folktale 一个规范的函数式编程库。和 lodash、ramda 不同的是，他没有提供很多性能函数。只提供了一些函数式解决的操作，例如：compose、curry 等，一些函子 Task、Either、MayBe 等

首先装置 folktale 的库

npm i folktale

const {compose, curry} = require('folktale/core/lambda')

// curry 中的第一个参数是函数有几个参数，为了防止一些谬误
const f = curry(2, (x, y) => x + y)

console.log(f(1, 2)) // 3
console.log(f(1)(2)) // 3

const {compose, curry} = require('folktale/core/lambda')
const {toUpper, first} = require('lodash/fp')

// compose 组合函数在 lodash 外面是 flowRight
const r = compose(toUpper, first)
console.log(r(['one', 'two']))  // ONE

folktale(2.3.2) 2.x 中的 Task 和 1.0 中的 Task 区别很大，1.0 中的用法更靠近咱们当初演示的

函子

这里以 2.3.2 来演示

const {task} = require('folktale/concurrency/task')
const fs = require('fs')
// 2.0 中是一个函数，函数返回一个函子对象
// 1.0 中是一个类

// 读取文件
function readFile (filename) {
  // task 传递一个函数，参数是 resolver
  // resolver 外面有两个参数，一个是 reject 失败的时候执行的，一个是 resolve 胜利的时候执行的
  return task(resolver => {
    //node 中读取文件，第一个参数是门路，第二个是编码，第三个是回调，谬误在先
    fs.readFile(filename, 'utf-8', (err, data) => {if(err) resolver.reject(err)
      resolver.resolve(data)
    })
  })
}

// 演示一下调用
// readFile 调用返回的是 Task 函子，调用要用 run 办法
readFile('package.json')
  .run()
  // 当初没有对 resolve 进行解决，能够应用 task 的 listen 去监听获取的后果
  // listen 传一个对象，onRejected 是监听谬误后果，onResolved 是监听正确后果
  .listen({onRejected: (err) => {console.log(err)
    },
    onResolved: (value) => {console.log(value)
    }
  })
 
 /** {
    "name": "Functor",
    "version": "1.0.0",
    "description": "","main":"either.js","scripts": {"test":"echo \"Error: no test specified\" && exit 1"},"keywords": [],"author":"",
    "license": "ISC",
    "dependencies": {
      "folktale": "^2.3.2",
      "lodash": "^4.17.20"
    }
  }
  */

在 package.json 文件中提取一下 version 字段

const {task} = require('folktale/concurrency/task')
const fs = require('fs')
const {split, find} = require('lodash/fp')
// 2.0 中是一个函数，函数返回一个函子对象
// 1.0 中是一个类

// 读取文件
function readFile (filename) {
  // task 传递一个函数，参数是 resolver
  // resolver 外面有两个参数，一个是 reject 失败的时候执行的，一个是 resolve 胜利的时候执行的
  return task(resolver => {
    //node 中读取文件，第一个参数是门路，第二个是编码，第三个是回调，谬误在先
    fs.readFile(filename, 'utf-8', (err, data) => {if(err) resolver.reject(err)
      resolver.resolve(data)
    })
  })
}

// 演示一下调用
// readFile 调用返回的是 Task 函子，调用要用 run 办法
readFile('package.json')
  // 在 run 之前调用 map 办法，在 map 办法中会解决的拿到文件返回后果
  // 在应用函子的时候就没有必要想的实现机制
  .map(split('\n'))
  .map(find(x => x.includes('version')))
  .run()
  // 当初没有对 resolve 进行解决，能够应用 task 的 listen 去监听获取的后果
  // listen 传一个对象，onRejected 是监听谬误后果，onResolved 是监听正确后果
  .listen({onRejected: (err) => {console.log(err)
    },
    onResolved: (value) => {console.log(value) // "version": "1.0.0",
    }
  })

Pointed 函子是实现了 of 静态方法的函子

of 办法是为了防止应用 new 来创建对象，更深层的含意是of 办法用来把值放到上下文

Context（把值放到容器中，应用 map 来解决值）

class Container { 
// Point 函子
// 作用是把值放到一个新的函子外面返回，返回的函子就是一个上下文
    static of (value) {return new Container(value)
    }
    ……  
}

// 调用 of 的时候取得一个上下文，之后是在上下文中解决数据
Contanier.of(2)
 .map(x => x + 5)

用来解决 IO 函子多层嵌套的一个问题

const fp = require('lodash/fp')
const fs = require('fs')

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

  map(fn) {return new IO(fp.flowRight(fn, this._value))
  }
}

// 读取文件函数
let readFile = (filename) => {return new IO(() => {
    // 同步获取文件
    return fs.readFileSync(filename, 'utf-8')
  })
}

// 打印函数
// x 是上一步的 IO 函子
let print = (x) => {return new IO(()=> {console.log(x)
    return x
  })
}

// 组合函数，先读文件再打印
let cat = fp.flowRight(print, readFile)
// 调用
// 拿到的后果是嵌套的 IO 函子 IO(IO(x))
let r = cat('package.json')
console.log(r) 
// IO {_value: [Function] }
console.log(cat('package.json')._value()) 
// IO {_value: [Function] }
// IO {_value: [Function] }
console.log(cat('package.json')._value()._value())
// IO {_value: [Function] }
/**
 * {
  "name": "Functor",
  "version": "1.0.0",
  "description": "","main":"either.js","scripts": {"test":"echo \"Error: no test specified\" && exit 1"},"keywords": [],"author":"",
  "license": "ISC",
  "dependencies": {
    "folktale": "^2.3.2",
    "lodash": "^4.17.20"
  }
}
 */

下面遇到多个 IO 函子嵌套的时候，那么_value 就会调用很屡次，这样的调用体验很不好。所以进行优化。

Monad 函子是能够变扁的 Pointed 函子，用来解决 IO 函子嵌套问题，IO(IO(x))
一个函子如果具备 join 和 of 两个办法并恪守一些定律就是一个 Monad

理论开发中不会这么难，次要是晓得 monad 的实现

const fp = require('lodash/fp')
const fs = require('fs')

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

  map(fn) {return new IO(fp.flowRight(fn, this._value))
  }

  join () {return this._value()
  }

  // 同时调用 map 和 join 办法
  flatMap (fn) {return this.map(fn).join()}
}

let readFile = (filename) => {return new IO(() => {return fs.readFileSync(filename, 'utf-8')
  })
}

let print = (x) => {return new IO(()=> {console.log(x)
    return x
  })
}

let r = readFile('package.json')
          .flatMap(print)
          .join()     
// 执行程序
/**
 * readFile 读取了文件，而后返回了一个 IO 函子
 * 调用 flatMap 是用 readFile 返回的 IO 函子调用的
 * 并且传入了一个 print 函数参数
 * 调用 flatMap 的时候，外部先调用 map，以后的 print 和 this._value 进行合并，合并之后返回了一个新的函子
 *（this._value 就是 readFile 返回 IO 函子的函数：*      () => {return fs.readFileSync(filename, 'utf-8')
        }
 *）* flatMap 中的 map 函数执行完，print 函数返回的一个 IO 函子，外面包裹的还是一个 IO 函子
 * 上面调用 join 函数，join 函数就是调用返回的新函子外部的 this._value()函数
 * 这个 this._value 就是之前 print 和 this._value 的组合函数，调用之后返回的就是 print 的返回后果
 * 所以 flatMap 执行结束之后，返回的就是 print 函数返回的 IO 函子
 *  */
 
 r = readFile('package.json')
        // 解决数据，间接在读取文件之后，应用 map 进行解决即可
        .map(fp.toUpper)
        .flatMap(print)
        .join()  

// 读完文件之后想要解决数据，怎么办？// 间接在读取文件之后调用 map 办法即可

/**
 * {
  "NAME": "FUNCTOR",
  "VERSION": "1.0.0",
  "DESCRIPTION": "","MAIN":"EITHER.JS","SCRIPTS": {"TEST":"ECHO \"ERROR: NO TEST SPECIFIED\" && EXIT 1"},"KEYWORDS": [],"AUTHOR":"",
  "LICENSE": "ISC",
  "DEPENDENCIES": {
    "FOLKTALE": "^2.3.2",
    "LODASH": "^4.17.20"
  }
}
 */

什么是 Monad？

具备动态的 IO 办法和 join 办法的函子

什么时候应用 Monad?

当一个函数返回一个函子的时候，咱们就要想到 monad，monad 能够帮咱们解决函子嵌套的问题。
当咱们想要返回一个函数，这个函数返回一个值，这个时候能够调用map 办法
当咱们想要去合并一个函数，然而这个函数返回一个函子，这个时候咱们要用flatMap 办法

函数式编程（一）—— 前置常识
函数式编程（二）—— 纯函数
函数式编程（三）—— 柯里化
函数式编程（四）——函数组合
函数式编程（五）——函子

正文完

javascript

发表至： javascript

2020-08-24

0

利用VUE异步组件动态加载组件实现自定义组件顺序动态绑定传入子组件的props动态绑定监听子组件的emit事件

分析 HTTP 203 出的一个 JS 题目

关于javascript:ArcGIS-for-JS-argis地图限制显示不规则区域

Vue中的set的使用

关于css:CSS样式全部属性和难记忆点归纳

关于javascript:函数式编程五-函子

Functor

为什么要学函子？

什么是 Functor

了解 Functor

总结

MyBe 函子

Either 函子

IO 函子

Task 函子（异步执行）

folktale 的装置

folktale 中的 curry 函数

folktale 中的 compose 函数

Task 函子异步执行

案例

Pointed 函子

Monad 函子（单子）

IO 函子的嵌套问题

什么是 Monad 函子

实现一个 Monad 函子

Monad 函子小结

什么是 Monad？

什么时候应用 Monad?

函数式编程总体设计

站内搜索