Alexei-B/LICENSE.txt

I really like how this turned out as I found most online examples of a generic curry function in javascript to be ugly as all heck. Note that this does not slice the arguments, meaning V8 won't have any problems here.

If you want a version of this that is a bit more readable then I recommend the following code:

function curry(fn, scope, args) {
    args = args || [];

    if (args.length >= fn.length)
        return fn.apply(scope, args);

    return function() {
        return curry(fn, scope,
                 args.concat.apply(args, arguments)
                );
    };
}

This code works in the same way however I've renamed the variables and reformatted it.

Here are some examples of using the function:

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

// typical use
var partial = curry(example)(1, 2);
partial(3) // 6
partial(4) // 7

// chained use
var partial2 = curry(example)(1);
partial2(2)(3) // 6
partial2(2)(4) // 7

// with optional arguments supplied
curry(example, window, [1, 2, 3]) // 6

// math functions
var pow2 = curry(Math.pow, Math)(2);
pow2(10) // 1024

// webgl functions
var canvas = document.createElement("canvas");
var gl = canvas.getContext("experimental-webgl");

var bindArrayBuffer = curry(gl.bindBuffer, gl)(gl.ARRAYBUFFER);

You can see a live version of the test code here: http://jsbin.com/rasema/edit?html,output

Thanks to @jed for the examples, I just dropped this to 126 bytes after realising I could name the function as seen here: https://gist.github.com/jed/964769

Just found out I can save 8 bytes removing the ||window after s because if you pass undefined to apply it will use the global scope.

Save another character with the help of your friendly neighborhood JS code golf caddy:

function c(f,s,a){return(a=a||[]).length<f.length?function(){return c(f,s,a.concat.apply(a,arguments))}:f.apply(s,a)}

@atk nice! I've updated it to match and also renamed the variables to follow the abc's I see a lot on 140bytes.

The abc's is not a neccessarity; it's just easier to remember their order.

Eh, if nothing else consistency is worth effort right?

That's true 👍

Thanks to ECMA6 this is now only 73 bytes, and makes more sense to call.

You can now follow the pattern shown here;

var temp = curry(fn, scope, arg1, arg2)(arg3);
temp(arg4, arg5)(arg6);

Additionally if you don't need a scope argument it can be reduced to 64 bytes:

a=(b,...c)=>c.length<b.length&&((...d)=>a(b,...c,...d))||b(...c)

Golf'd.