函子的简单介绍

为什么要学函子

函数式编程中如何把副作用控制在可控的范围内、异常处理、异步操作等。

什么是函子

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

Functor（函子） 

// ES6中引入类的概念，但是js中没有一个真正的class原始类型，仅仅只是对原型对象运用【语法糖】，所
// 以只有理解如何使用原型对象实现类和继承，才能真正的用好
class Container {
    // 实现of静态方法，不用每次都调用new Container创建对象
    static of(value) {
        return new Container(value)
    }

    // 创建构造函数，将传入的value值包含在容器内部（不对外展示）
    constructor(value) {
        // _开头的变量一般定义为内部属性
        // 通常变量前加下划线表示“私有变量”。函数名前加下划线表示“私有函数”。
        this._value = value
    }

    // 向外部抛出map函数，用于接收处理value的方法
    map(fn) {
        return Container.of(fn(this._value))
    }
}

// 测试
let r = Container.of(3)
    .map(x => x + 2)
    .map(x => x * x)
console.log(r)
//  ==>Container { _value: 25 }

• 总结
  • 函数式编程的运算不直接操作值，而是由函子完成
  • 函子就是一个实现了map契约的对象
  • 我们可以把函子想象成一个盒子，盒子内部封装一个值（value），不对外公布
  • 想要处理盒子中的值，我们需要给盒子的map方法传递一个处理值得函数（纯函数），由这个函数来对值进行处理
  • 最终map方法返回一个包含新值得盒子（函子），多次调用map方法，会形成函子嵌套
• 在Functor中如果传入空值（副作用）

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
    }

    isNothing() {
        return this._value === null || this._value === undefined
    }

    // 如果对空值变形的话直接返回【值为null的函子】
    map(fn) {
        return this.isNothing() ? MayBe.of(null) : MayBe.of(fn(this._value))
    }
}

// 传入具体值
let r1 = MayBe.of('Hello world')
    .map(x => x.toUpperCase())
console.log(r1)  // MayBe { _value: 'HELLO WORLD' }
// 传入null的情况
let r2 = MayBe.of(null)
    .map(x => x.toUpperCase())
console.log(r2)  // 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)  // Right { _value: 'ZS' }

IO函子

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

const fs = require('lodash/fp')

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

    constructor(fn) {
        this._value = fn
    }

    map(fn) {
        // 把当前的value和传入的fn函数组合成一个新的函数
        return new IO(fp.flowRight(fn, this._value))
    }
}

// 调用
let io = IO.of(process)
    .map(p => p.execPath)

console.log(io._value)  //

Task异步执行

• 异步任务的实现过于复杂，我们使用folktale中的Task来演示
• folktale是一个标准的函数编程库
  • 和 lodash、ramda 不同的是，他没有提供很多功能函数
  • 只提供了一些函数式处理的操作，例如：compose、curry 等，一些函子 Task、Either、
    MayBe 等

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

// 第一个参数是传入函数的参数个数
let f = curry(2, function (x, y) {
    console.log(x + y)
})
f(3, 4)
f(3)(4)
// 7
// 7

// 函数组合
let r = compose(toUpper, first)
f(['one', 'two'])
console.log(r)
// [function]

 Task 异步执行

• 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')
const {split, find} = require('lodash/fp')

function readFile(filename) {
    return task(resolver => {
        fs.readFile(filename, 'utf-8', (err, data) => {
            if (err) resolver.reject(err)
            resolver.resolve(data)
        })
    })
}

// 调用run执行
readFile('package.json')
    .map(split('\n'))
    .map(find(x => x.includes('version')))
    .run().listen({
    onRejected: err => {
        console.log(err)
    },
    onResolved: value => {
        console.log(value)
    }
})

Pointed函子

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

class Container {
    static of (value) {
        return new Container(value)
    }
……
}
Contanier.of(2)
    .map(x => x + 5)

Monad函子

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

// IO Monad
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))
    }

    join() {
        return this._value()
    }

    flatMap(fn) {
        return this.map(fn).join()
    }
}

let r = readFile('package.json')
    .map(fp.toUpper)
    .flatMap(print)
    .join()