為什麼要學函子

函數語言程式設計中如何把副作用控制在可控的範圍內、異常處理、非同步操作等。

什麼是函子

• 容器：包含值和值的變形關係(這個變形關係就是函式)
• 函子：是一個特殊的容器，通過一個普通的物件來實現，該物件具有 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()