【函数式编程】函子 about basic-programming-knowledge HOT 1 OPEN

// Just为我们的一个“函子”
function Just(value) {
    return {
        value, // 保存值
        // 值为基本数据，支持映射到范畴（Just）内其他元素
        // addOne = x => x + 1
        // 比如 Just(1).map(addOne)    -> Just(2)
        map: function map(fn) {
            return Just(fn(value))
        },
        // 值为基本数据，支持映射到自身范畴
        // 比如 Just(1).flatMap(addOne)    -> 2
        flatMap: function flatMap(fn) {
            return fn(value);  
        },
        // 值为函数（映射），支持映射到范畴（Just）内的其他元素
        // 比如Just((x) => x + 1).fmap(Just(2))     -> Just(3)
        fmap: function fmap(just) { // 函子 Just(compose(b, a)) = composeJust(Just(b), Just(a));
            return just.map(value);
        },
        id: function id(anything) {
            return Just(value);
        }
    }
}

var id = (x) => x;
// 在Number范畴中，id函数自等，即x = id(x)
var a = 1;
console.log(a === id(a)); // true

// 在Just范畴中
var ja = Just(1);
function eq(justa, justb) { // 实现一个Just范畴的判等函数
     return justa.flatMap(id) === justb.flatMap(id);
}

console.log(eq(ja, ja.id(ja))); // true 等于实现Just范畴中的 === 操作
Just(id).fmap(Just(999)); // Just(999)  等于实现Just范畴中的 fmap id = id

// 需要实现操作: fmap (g . f) = (fmap g) . (fmap f)

var a = 3;
var square = x => x * x;
var addOne = x => x + 1;

// Number范畴中
var compose = (g, f) => x => g(f(x))
var compound = compose(square, addOne);
console.log(compound(a)); // (3 + 1) ^2 = 16

Just(compound)
    .fmap(Just(a)) // Just(16) 等于实现了 fmap compound =
Just(square)
    .fmap(
        Just(addOne).fmap(Just(a))
    ) // Just(16) 等于实现了= fmap f . fmap g

function addThree(a, b, c) {
    return a + b + c;
}

var add = a => b => a + b;
var addThree = compose(add(c), add(b), add(a))(0)