函数式编程-函子（3）

Functor（函子）

函数式程序即通过管道把数据在一系列的纯函数间传递的程序。但是对于异常处理，异步操作，副作用如何处理？这个时候就需要容器即函子。

什么是Functor

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

Functor函子

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

Container.of(3)
    .map(x => x + 2)
    .map(x => x * x)

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

MayBe函子

• 在Functor中如果我们传入null或undefined

Container.of(null).map(x => x.toUpperCase())

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

class MayBe {
    static of(value) {
        return new MayBe(value);
    }
    constructor(value) {
        this._value = value;
    }
    map(fn) {
        return this.isNothing()
            ? MayBe.of(this._value)
            : MayBe.of(fn(this._value));
    }
    isNothing() {
        return this._value === null || this._value === undefined;
    }
}
console.log(MayBe.of("Hello world").map((x) => x.toUpperCase()));
console.log(MayBe.of(undefined).map((x) => x.toUpperCase()));

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

MayBe.of("hello world")
    .map((x) => x.toUpperCase())
    .map((x) => null)
    .map((x) => x.split(" "));

Either函子

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

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

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

IO函子

• IO函子中的_value是一个函数，这里是把函数作为值来处理
• IO函子可以把不纯的动作存储到_value中，延迟执行这个不纯的操作（惰性执行），包装当前的操作
• 把不纯的操作交给调用者来处理

const fp = require("lodash/fp");
class IO {
    static of(x) {
        return new IO(function () {
            return x;
        });
    }
    constructor(fn) {
        this._value = fn;
    }
    map(fn) {
        return new IO(fp.flowRight(fn, this._value));
    }
}
let io = IO.of(process)
    .map((p) => p.execPath)
    .map((p) => p.toUpperCase());
console.log(io._value());

异步函子

• 异步函子采用 folktable来实现

const { task } = require("folktale/concurrency/task");

var fs = require("fs");

var readFile = function (filename) {
    return new task(function ({ reject, resolve }) {
        fs.readFile(filename, "utf-8", function (err, data) {
            err ? reject(err) : resolve(data);
        });
    });
};

readFile("./package.json")
    .map((data) => data.toUpperCase())
    .run()
    .listen({
        onCancelled: () => {
            console.log("the task was cancelled");
        },
        onRejected: (error) => {
            console.log("something went wrong");
        },
        onResolved: (value) => {
            console.log(value);
        },
    });

• map类似promise的then方法，与IO其实类似，只是Task在给绿灯前是不会运行的。而是在处理完异步之后运行。我们调用run方法运行该函子。

Pointed函子

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

class Container {
  static of(value) {
    return new Container(value)
  }
  map() {
    ...
  }
}

Contanier.of(2).map(...)