How can I make Underscore behave like Ramda?

Taking the question very literally, let's just start with a function that transforms a data-first function into a data-last function:

const dataLast = f => _.restArguments(function(args) {
    args.unshift(args.pop());
    return f.apply(this, args);
});

const dataLastMap = dataLast(_.map);
dataLastMap(square, [1, 2, 3]);  // [1, 4, 9]

We could map dataLast over Underscore to get a data-last version of the entire library:

const L = _.mapObject(_, dataLast);
const isOdd = x => x % 2;

L.map(square, [1, 2, 3]);  // [1, 4, 9]
L.filter(isOdd, [1, 2, 3]);  // [1, 3]

However, we can do better. Ramda-style currying is not too hard to implement, either:

const isPlaceholder = x => x === _;

function curry(f, arity = f.length, preArgs = []) {
    const applied = _.partial.apply(null, [f].concat(preArgs));
    return _.restArguments(function(args) {
        const supplied = _.countBy(args, isPlaceholder)['false'];
        if (supplied < arity) {
            return curry(applied, arity - supplied, args);
        } else {
            return applied.apply(null, args);
        }
    });
}

With just a little bit of extra sophistication, we can even correctly support this bindings:

function curry(f, arity = f.length, preArgs = [], thisArg) {
    if (!_.isUndefined(thisArg)) f = f.bind(thisArg);
    const applied = _.partial.apply(null, [f].concat(preArgs));
    return _.restArguments(function(args) {
        const supplied = _.countBy(args, isPlaceholder)['false'];
        if (supplied < arity) {
            return curry(applied, arity - supplied, args, this);
        } else {
            return applied.apply(this, args);
        }
    });
}

Currying by itself is independent of whether you do data-first or data-last. Here's a curried version of _.map that is still data-first:

const curriedMap = curry(_.map);

curriedMap([1, 2, 3], square, null);
curriedMap([1, 2, 3])(square, null);
curriedMap([1, 2, 3])(square)(null);
curriedMap([1, 2, 3], square)(null);
curriedMap([1, 2, 3], _, null)(square);
curriedMap(_, _, null)([1, 2, 3], square);
curriedMap(_, _, null)(_, square)([1, 2, 3]);
curriedMap(_, square, _)(_, null)([1, 2, 3]);
// all [1, 4, 9]

Note that I have to pass null every time, because _.map takes an optional third argument that lets you bind the callback to a context. This eager style of currying forces you to pass a fixed number of arguments. In the Variation section below, I'll show how this can be avoided with a lazy variant of curry.

The Ramda library omits the optional context parameter instead, so you need to pass exactly two instead of exactly three arguments to R.map. We can write a function that composes dataLast and curry and that optionally adjusts the arity, in order to make an Underscore function behave exactly like its Ramda counterpart:

const ramdaLike = (f, arity = f.length) => curry(dataLast(f), arity);

const ramdaMap = ramdaLike(_.map, 2);

ramdaMap(square, [1, 2, 3]);
ramdaMap(square)([1, 2, 3]);
ramdaMap(_, [1, 2, 3])(square);
// all [1, 4, 9]

Mapping this over the entire library requires some administration in order to get a satisfying result, but the result is a surprisingly faithful imitation of Ramda:

const arityOverrides = {
    map: 2,
    filter: 2,
    reduce: 3,
    extend: 2,
    defaults: 2,
    // etcetera, as desired
};

const R_ = _.extend(
    // start with just passing everything through `ramdaLike`
    _.mapObject(_, f => ramdaLike(f)),
    // then replace a subset with arity overrides
    _.mapObject(arityOverrides, (arity, name) => ramdaLike(_[name], arity)),
);

R_.identity(1);               // 1
R_.map(square)([1, 2, 3]);    // [1, 4, 9]
R_.filter(isOdd)([1, 2, 3]);  // [1, 3]

const add = (a, b) => a + b;
const sum = R_.reduce(add, 0);
sum([1, 2, 3]);               // 6

Variation

At the cost of introducing laziness, we can avoid having to fix the arity of a function. This lets us preserve all the optional and variadic parameters from the original Underscore functions, without always needing to supply them, and removes the need for per-function administration when mapping the library. We start with a variant of curry that returns a lazy function instead of an eager one:

function curryLazy(f, preArgs = [], thisArg) {
    if (!_.isUndefined(thisArg)) f = f.bind(thisArg);
    const applied = _.partial.apply(null, [f].concat(preArgs));
    return _.restArguments(function(args) {
        if (args.length > 0) {
            return curryLazy(applied, args, this);
        } else {
            return applied.call(this);
        }
    });
}

This is basically R.curry with a builtin R.thunkify on top. Note that this implementation is actually a bit simpler than the eager variant. On top of that, creating a lazy, Ramda-like port of Underscore is reduced to an elegant oneliner:

const LR_ = _.mapObject(_, _.compose(curryLazy, dataLast));

We can now pass as many or as few arguments to each function as we want. We just have to append an extra call without arguments in order to force evaluation:

LR_.identity(1)();  // 1

LR_.map([1, 2, 3])();                   // [1, 2, 3]
LR_.map(square)([1, 2, 3])();           // [1, 4, 9]
LR_.map(_, [1, 2, 3])(square)();        // [1, 4, 9]
LR_.map(Math.sqrt)(Math)([1, 4, 9])();  // [1, 2, 3]

LR_.filter([1, false, , '', 'yes'])();            // [1, 'yes']
LR_.filter(isOdd)([1, 2, 3])();                   // [1, 3]
LR_.filter(_, [1, 2, 3])(isOdd)();                // [1, 3]
LR_.filter(window.confirm)(window)([1, 2, 3])();  // depends on user

LR_.extend({a: 1})({a: 2, b: 3})();
// {a: 1, b: 3}
LR_.extend({a: 1})({a: 2, b: 3})({a: 4})({b: 5, c: 6})();
// {a: 4, b: 3, c: 6}

This trades some faithfulness to Ramda for faithfulness to Underscore. In my opinion, it is a best of both worlds: data-last currying like in Ramda, with all the parametric flexibility from Underscore.

References:

• Underscore documentation
• Ramda documentation