函数式编程初探

March 11, 2022

utils: Ramda, Lodash/fp
简单实现

柯里化 curry

curried(x, y, z) = curried(x, y)(z) = curried(x)(y, z) = curried(x)(y)(z)

function curry(func) {
    return function curried(...args) {
        if (args.length >= func.length) {
            return func.apply(this, args);
        } else {
            return function (...args2) {
                return curried.apply(this, args.concat(args2));
            };
        }
    };
}

// Functor f => (a → b) → f a → f b
const map = curry((f, ary) => ary.map(f));

代码组合 compose/pipe

compose(f, g, h) == f•g•h

compose(f, compose(g, h)) = compose(compose(f, g), h) = compose(f, g, h)
const compose = (...args) => params => args.reduceRight((pre, next) => next(pre), params);

R.compose(Math.abs, R.add(1), R.multiply(2))(-4); // |(-4) * 2 + 1| = 7

pipe(f, g, h) == h•g•f

const pipe = (...args) => params => args.reduce((pre, next) => next(pre), params);

R.pipe(Math.pow, R.negate, R.inc)(3, 4); // -(3^4) + 1 = -80

id

const id = (x) => x;

函子 Functor

functor 是实现了 map 函数并遵守一些特定规则的容器类型。

class Functor {
    constructor(val) {
        this.val = val;
    }
    // pointed functor 是实现了 of 方法的 functor
    of(val) {
        return new this.constructor(val);
    }
    map(f) {
        return this.of(f(this.val));
    }
}

Maybe

Maybe 函子的 map 方法会自行做空值检查，空值则不调用 f 函数

class Maybe extends Functor {
    isNothing() {
        return this.val === null || this.val === undefined;
    }
    map(f) {
        return this.isNothing() ? this.of(null) : this.of(f(this.val));
    }
}

//  maybe :: b -> (a -> b) -> Maybe a -> b
const maybe = curry((x, f, m) => (m.isNothing() ? x : f(m.val)));

Either

Either 函子的 map 方法先右值再左值

class Either extends Functor {
    constructor(left, right) {
        this.left = left;
        this.right = right;
    }

    map(f) {
        return this.right ? Either.of(this.left, f(this.right)) : Either.of(f(this.left), this.right);
    }
}

Either.of = function (left, right) {
    return new Either(left, right);
};

class Left {
    constructor(val) {
        this.val = val;
    }
    map(f) {
        return this;
    }
}
class Right {
    constructor(val) {
        this.val = val;
    }
    map(f) {
        return new Right(f(this.val));
    }
}
//  either :: (a -> c) -> (b -> c) -> Either a b -> c
const either = curry((f, g, e) => {
    switch (e.constructor) {
        case Left:
            return f(e.__value);
        case Right:
            return g(e.__value);
    }
});

Monad

一个 functor，只要它定义个了一个 join 方法和一个 of 方法，并遵守一些定律，那么它就是一个 monad

class Monad extends Maybe {
    join() {
        return this.isNothing() ? this.of(null) : this.val;
    }
    map(f) {
        return this.of(f(this.val)).join();
    }
    // of
}

IO

class IO extends Monad {}

Ap

class Ap extends Functor {
    ap(F) {
        return this.of(this.val(F.val));
    }
}

←Back to home