A simple implementation of a Maybe Monad

maybe.js

const identity = x => x;

function Just (v) {
    return { map, chain, ap };

    function map (fn) {
        return Just(fn(v))
    }
    
    function chain (fn) {
        return fn(v);
    }
    // not really mathematically sound, but not imperative to the endeavor at hand either
    function ap (another) {
        return another.map(v);
    }
}

function Nothing () {
    return { map: Nothing, chain: Nothing, ap: Nothing };
}

const Maybe = { Just, Nothing, of: Just } 

function fromNullable (val) {
    if (val == null) return Maybe.Nothing();
    return Maybe.of(val);
}

function prop (prop) {
    return function (obj) {
        return fromNullable(obj[prop]);
    }
}


const obj = {
    a: {
        a: {
          a: 1
        }
    },
    b: 2,
    c: 3
};


Maybe.of(obj)
    .chain(prop('a'))
    .chain(prop('a'))
    .chain(prop('a'))
    .chain(identity);

semigroups.js

const Sum = x => ({
    x,
    concat: other => 
        Sum(x + other.x)
});
Sum.empty = () => Sum(0);

const Product = x => ({
    x,
    concat: other => 
        Product(x * other.x)
});
Product.empty = () => Product(1);

const Any = x => ({
    x,
    concat: other => 
        Any(x || other.x)
});
Any.empty = () => Any(false);