一 函子 Functor

  1. 函子就是个容器，他有个值并且有个map方法,map方法可以运行一个函数对值进行处理；如何把副作用控制在可控的范围内、异常操作、异步操作等可能需要用到函子；
  1. // 函子
  2. // class Container {
  3. //     constructor(value) {
  4. //         this._value = value;
  5. //     }
  7. //     map(fn) {
  8. //         return new Container(fn(this._value));
  9. //     }
  10. // }
  12. // const a = new Container(5)
  13. //         .map( x => x + 1)
  14. //         .map( x => x * x);
  15. // console.log(a);
  17. class Container {
  18.     static of (value) {
  19.         return new Container(value)
  20.     }
  21.     constructor(value) {
  22.         this._value = value;
  23.     }
  25.     map(fn) {
  26.         return new Container(fn(this._value));
  27.     }
  28. }
  30. console.log(Container.of(5).map(x => x + 1).map( x => x * x))

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

二 mayBe函子

处理异常操作

  1. class Maybe {
  2.     static of (value) {
  3.         return new Maybe(value)
  4.     }
  5.     constructor(value) {
  6.         this._value = value;
  7.     }
  9.     map(fn) {
  10.         return this.isNothing() ? Maybe.of(null): Maybe.of(fn(this._value))
  11.     }
  13.     isNothing() {
  14.         return this._value === null || this._value === undefined;
  15.     }
  16. }
  17. // console.log(Maybe.of('hello world').map(x => x.toUpperCase()));
  18. // 可以处理空值
  19. // const r = Maybe.of(null).map(x => x.toUpperCase());
  20. // 发生在哪一步不知道
  21. const r = Maybe.of(null)
  22.             .map(x => x.toUpperCase())
  23.             .map(x => null)
  24.             .map(x => x.split(' '));
  26. console.log(r)

三 either函子

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

  1. class Container {
  2.     static of (value) {
  3.         return new Container(value)
  4.     }
  5.     constructor(value) {
  6.         this._value = value;
  7.     }
  9.     map(fn) {
  10.         return Container.of(fn(this._value));
  11.     }
  12. }
  13. class Left extends Container{
  14.     map(fn) {
  15.         return this
  16.     }
  17. }
  18. class Right extends Container{
  19. }
  20. function parseJSON (str) {
  21.     try{
  22.         return Right.of(JSON.parse(str))
  23.     } catch(error) {
  24.         return Left.of({error: error.message})
  25.     }
  26. }
  27. // const r1 = Right.of(12)
  28. //             .map(x => x + 2);
  29. // const r2 = Left.of(12)
  30. //             .map(x => x + 2);
  31. // const r3 = parseJSON('{name: zhangSan}')
  32. const r4 = parseJSON('{"name": "zhangSan"}')
  33.                 .map(x => x.name.toUpperCase())
  34. // console.log(r1)
  35. // console.log(r2)
  36. // console.log(r3)
  37. console.log(r4)

四 IO函子

  1. IO函子中的_value是个函数，这里把函数当作值处理；IO函子可以把不纯的动作存储到_value中，延迟执行这个不纯的操作（惰性行为），包装当前的操作；把不纯的操作当作调用者来处理；
  1. const fp = require('loadsh/fp');
  3. class IO {
  4.     static of(value) {
  5.         return new IO(function() {
  6.             return value;
  7.         });
  8.     }
  10.     constructor(fn) {
  11.         this._value = fn;
  12.     }
  14.     map (fn) {
  15.         return new IO(fp.flowRight(fn, this._value))
  16.     }
  17. }
  18. // 调用
  19. let r = IO.of(process).map( p => p.execPath);
  20. // console.log(r);
  21. console.log(r._value());

五 folktale

一个标准的函数式编程库，异于lodash、ramda，他没有提供很多功能函数；只提供了函数式的操作，如compose、curry等，一些函子Task、Eithger、Maybe等；
异步任务的实现过于复杂，用folktale中的task来演示

  1. // folktale 中的 curry/compose函数
  2. const {compose, curry} = require ('folktale/core/lambda');
  3. const {toUpper, first} = require('lodash/fp');
  4. // let f = curry(2, (x, y) => x + y);
  6. // console.log(f(2,3));
  7. // console.log(f(2)(3))
  9. const f = compose(toUpper, first);
  11. console.log(f(['one', 'two']))

folktale task异步执行 folktale2.和folktal1.中的task区别很大，1.0中的用法更接近我们现在演示的函子

  1. const fs = require('fs');
  2. const {task} = require('folktale/concurrency/task');
  3. const {split, find} = require('loadsh/fp');
  5. function readFile(fileName) {
  6.     return task(resolver => {
  7.         fs.readFile(fileName, 'utf-8', (err, data) => {
  8.             if(err) resolver.reject(err)
  10.             resolver.resolve(data)
  11.         })
  12.     })
  13. }
  15. readFile('package.json')
  16.     .map(split('\n'))
  17.     .map(find(x => x.includes('version')))
  18.     .run()
  19.     .listen({
  20.         onRejected: err => {
  21.             console.log(err)
  22.         },
  23.         onResolved: data => {
  24.             console.log(data)
  25.         }
  26.     })

六 pointed函子

实现了of静态方法的函子，of方法是为了避免使用new来创建对象，更深层次的含义是of方法用来把值放到上下文context（把值放到容器中，使用map来处理值）

七 io函子的问题

  1. const fp = require('loadsh/fp');
  2. const fs = require('fs');
  3. class IO {
  4.     static of(value) {
  5.         return new IO(function() {
  6.             return value;
  7.         });
  8.     }
  10.     constructor(fn) {
  11.         this._value = fn;
  12.     }
  14.     map (fn) {
  15.         return new IO(fp.flowRight(fn, this._value))
  16.     }
  17. }
  19. const readFile = function(fileName) {
  20.     return new IO(function(){
  21.         return fs.readFileSync(fileName, 'utf-8')
  22.     });
  23. }
  25. const print = function(x) {
  26.     return new IO(function(){
  27.         console.log(x);
  28.         return x;
  29.     })
  30. }
  32. const cat = fp.flowRight(print, readFile);
  34. const r = cat('package.json')._value()._value();
  35. console.log(r)

八 monad 函子

可以变扁的poinged函子。变扁就是解决函数嵌套的问题；一个函子如果具有join和of的两个方法并遵守一些定律就是monad；

  1. const fp = require('loadsh/fp');
  2. const fs = require('fs');
  3. class IO {
  4.     static of(value) {
  5.         return new IO(function() {
  6.             return value;
  7.         });
  8.     }
  10.     constructor(fn) {
  11.         this._value = fn;
  12.     }
  14.     map (fn) {
  15.         return new IO(fp.flowRight(fn, this._value))
  16.     }
  18.     join() {
  19.         return this._value()
  20.     }
  22.     flatMap(fn) {
  23.         return this.map(fn).join();
  24.     }
  25. }
  27. const readFile = function(fileName) {
  28.     return new IO(function(){
  29.         return fs.readFileSync(fileName, 'utf-8')
  30.     });
  31. }
  33. const print = function(x) {
  34.     return new IO(function(){
  35.         console.log(x);
  36.         return x;
  37.     })
  38. }
  40. const r = readFile('package.json')
  41.             .map(fp.toUpper)
  42.             .flatMap(print)
  43.             .join()
  44. console.log(r)

九 函子的练习

support.js

  1. class Container {
  2.     static of(value) {
  3.         return new Container(value);
  4.     }
  6.     constructor(value) {
  7.         this._value = value;
  8.     }
  10.     map(fn) {
  11.         return Container.of(fn(this._value));
  12.     }
  13. }
  15. class MayBe {
  16.     static of(x) {
  17.         return new MayBe(x);
  18.     }
  20.     constructor(x) {
  21.         this._value = x;
  22.     }
  24.     isNothing() {
  25.         return this._value === null || this._value === undefined;
  26.     }
  28.     map(fn) {
  29.         return this.isNothing() ? this : MayBe.of(fn(this._value));
  30.     }
  31. }
  32. module.exports = { MayBe, Container };
  1. const fp = require('loadsh/fp');
  2. const {MayBe, Container} = require('./support');
  3. // 使用fp.add 和 fp.map创建一个能让functor里的值增加的函数
  4. let mayBe = MayBe.of([5, 6, 1]);
  5. let ex1 = () => {
  6.     return mayBe.map(fp.map( item => fp.add(item, item)))
  7. }
  8. console.log(ex1())
  10. // 使用一个函数ex2 能够使用fp.first获取列表的第一个元素
  11. let xs = Container.of(['do','ray','me','fa','so','la','ti','do']);
  13. let ex2 = () => {
  14.     return xs.map(fp.first)
  15. }
  16. console.log(ex2())
  18. // 实现一个函数ex3, 使用 safeProp 和 fp.first 找到user 名字的首字母
  19. let safeProp = fp.curry(function(x, o) {
  20.     return MayBe.of(o[x])
  21. });
  22. let user = {id: 2, name: 'Albert'};
  23. let ex3 = () => {
  24.     return safeProp('name', user).map(fp.first);
  25. }
  26. console.log(ex3())
  28. // 使用 Maybe 重写ex4，不要有if语句
  29. // let ex4 =  function(n) {
  30. //     if(n) return parseInt(n);
  31. // }
  33. let ex4 = (n) => {
  34.     return MayBe.of(n).map(parseInt)
  35. }