Как вы выполняете любую функцию javascript произвольной арности?

Я считаю, что вы могли бы просто использовать Function.prototype.bind. Это дает вам всю необходимую гибкость, независимо от того, хотите ли вы сразу получить результат функции или просто вставить другое значение в аргументы, пока вы не решите выполнить.

function sum() {
    return [].reduce.call(arguments, function (c, n) {
        return c + n;
    });
}

sum(1, 2); //3

var sum2 = sum.bind(null, 1, 2);

sum2(); //3

var sum3 = sum2.bind(null, 3);

sum3(); //6

Вы также можете использовать вспомогательную функцию, например:

function curry(fn) {
    var c = curry.bind(this, fn = fn.bind.apply(fn, [this].concat([].slice.call(arguments, 1))));

    c.exec = fn;

    return c;
}

curry(sum, 1, 2)(3)(4, 5)(6, 7, 8).exec(); //36

Кроме того, это очень гибко, так как вам не нужно создавать цепочку, вы можете повторно использовать одну и ту же каррированную функцию.

var sumOnePlus = curry(sum, 1);

sumOnePlus.exec(2); //3;
sumOnePlus.exec(3); //4;

Вот моя попытка:

function curry(fn, len) {
    if (typeof len != "number")
        len = fn.length; // getting arity from function
    return function curried() {
        var rlen = len - arguments.length;
        if (rlen <= 0) // then execute now
            return fn.apply(this, arguments);
        // else create curried, partially bound function:
        var bargs = [this]; // arguments for `bind`
        bargs.push.apply(bargs, arguments);
        return curry(fn.bind.apply(fn, bargs), rlen);
    };
}

Это не частичное приложение (что легко сделать в JS с bind метод), но действительно функциональный каррирование. Работает с любыми функциями произвольной, но фиксированной арности. Для вариативных функций вам понадобится другой триггер выполнения, возможно, когда аргументы больше не передаются, или метод exec, как в ответе @plalx.

Как насчет такого:

function makeLazy(fn) {
    var len = fn.length;
    var args = [];
    return function lazy() {
        args.push.apply(args, arguments);
        if (args.length < len) {
            return lazy;
        } else {
            return fn.apply(this, args);
        }
    }
}

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

var lazyF = makeLazy(f);
lazyF(1)(2)(3); // 6

var lazyF = makeLazy(f);
lazyF(1,2)(3); // 6

Если вам нужна повторно используемая функция (думаю, я не могу точно сказать, что вы хотите), то это сработает:

function makeCurry(fn) {
    return function curry() {
        var args = [].slice.call(arguments);
        return function() {
            return fn.apply(this, args.concat.apply(args, arguments));
        };
    }
}


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

var curryF = makeCurry(f);
var addOneTwoAnd = curryF(1,2);

addOneTwoAnd(3); // 6
addOneTwoAnd(6); // 9

Пожалуйста, проверьте библиотеку curry.

Он может превратить любую функцию в карри независимо от количества аргументов.

Пример:

> var curry = require('curry');
undefined
> var add = curry(function(a, b, c, d, e) { return a + b + c + d + e; });
undefined
> add(1)
[Function]
> add(1,2,3,4,5)
15
> add(1,2)(3,4)(5)
15
>

Метод bind() для функции позволяет привязать this внутри функции, а также привязать дополнительные параметры. Итак, если вы передадите null для параметра this, вы можете использовать bind() для каррирования параметров в функцию.

function g(a,b,c){ return a + b + c }

var g_1 = g.bind(null, 1);
console.log(g_1(2, 3)); // Prints 6

var g_1_2 = g.bind(null, 1, 2);
console.log(g_1_2(3)); // Prints 6

См. функция Javascript bind() для получения подробной информации и интерактивных примеров использования bind() для привязки параметров.