# curry

flexible but simple curry function

``npm install curry``

# CURRY

A curry function without anything too clever (... because hunger is the finest spice)

# Why

If you don't know currying, or aren't sold on it's awesomeness, perhaps a friendly blog post will help.

# API

### curry

``````var curry = require('curry');

//-- creating a curried function is pretty
//-- straight forward:
var add = curry(function(a, b){ return a + b });

//-- it can be called like normal:
add(1, 2) //= 3

//-- or, if you miss off any arguments,
//-- a new funtion that expects all (or some) of
//-- the remaining arguments will be created:

//-- curry knows how many arguments a function should take
//-- by the number of parameters in the parameter list

//-- in this case, a function and two arrays is expected
//-- (fn, a, b).  zipWith will combine two arrays using a function:
var zipWith = curry(function(fn, a, b){
return a.map(function(val, i){ return fn(val, b[i]) });
});

//-- if there are still more arguments required, a curried function
//-- will always return a new curried function:

//-- both functions are usable as you'd expect at any time:
zipAdd([1, 2, 3], [1, 2, 3]); //= [2, 4, 6]
zipAddWith123([5, 6, 7]); //= [6, 8, 10]

//-- the number of arguments a function is expected to provide
//-- can be discovered by the .length property
zipWith.length; //= 3
``````

### curry.to

Sometimes it's necessary (especially when wrapping variadic functions) to explicitly provide an arity for your curried function:

``````var sum = function(){
var nums = [].slice.call(arguments);
return nums.reduce(function(a, b){ return a + b });
}

var sum3 = curry.to(3, sum);
var sum4 = curry.to(4, sum);

sum3(1, 2)(3) //= 6
sum4(1)(2)(3, 4) //= 10
``````

It's a (sad?) fact that JavaScript functions are often written to take the 'context' object as the first argument.

With curried functions, of course, we want it to be the last object. `curry.adapt` shifts the context to the last argument, to give us a hand with this:

``````var delve = require('delve');
var delveC = curry.adapt(delve);

var getDataFromResponse = delveC('response.body.data');
getDataFromResponse({ response: { body: { data: { x: 2 }} } }); //= { x: 2 }
``````

Like `curry.adapt`, but the arity explicitly provided:

``````var _ = require('lodash');
var map = curry.adaptTo(2, _.map);
var mapInc = map(function(a){ return a + 1 })

mapInc([1, 2, 3]) //= [2, 3, 4]
``````

# installation

### node/npm

``````npm install curry
``````

### amd

``````define(['libs/curry.min'], function(curry){
//-- assuming libs/curry.min.js is the downloaded minified version from this repo,
//-- curry will be available here
});
``````

### browser

If you're not using tools like browserify or require.js, you can load curry globally:

``````<script src="libs/curry.min.js"></script>
<script>
<!-- curry available here -->
</script>
``````

∏∏

npm loves you