Lightweight Either Implementation. Mostly ripped off directly from @DrBoolean's Mostly Adequate Guide.

either.js

/**
 * Lightweight Either Implementation.
 * Mostly ripped off directly from @drboolean's Mostly Adequate Guide.
 * https://drboolean.gitbooks.io/mostly-adequate-guide/
 */
import {curry} from 'lodash/fp';

export function Left(x) {
    this.__value = x;
}

Left.of = function of(x) {
    return new Left(x);
};

Left.prototype.map = function map() {
    return this;
};

Left.prototype.join = function join() {
    return this;
};

Left.prototype.chain = function chain(fn) {
    return this.map(fn).join();
};

export function Right(x) {
    this.__value = x;
}

Right.of = function of(x) {
    return new Right(x);
};

Right.prototype.map = function map(f) {
    return Right.of(f(this.__value));
};

Right.prototype.join = function join() {
    return this.__value;
};

Right.prototype.chain = function chain(fn) {
    return this.map(fn).join();
};

/**
 * @function Either. Do something with an either value.
 * @param  {function} f Function to run if the value is Left
 * @param  {function} g Function to run if the value is Right.
 * @param  {Either}   e An Either monad containing either a Left or Right
 * @return {*}          The result of calling f or g on the corresponding Either value.
 */
export const either = curry(function either(f, g, e) { // eslint-disable-line prefer-arrow-callback
    switch (e.constructor) {
    case Left:
        return f(e.__value);
    case Right:
        return g(e.__value);
    default:
        throw new Error('Something weird passed to either');
    }
});