Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/dominictarr/curry
simple curry module, with nothing *too clever*, and full test coverage
https://github.com/dominictarr/curry
Last synced: 9 days ago
JSON representation
simple curry module, with nothing *too clever*, and full test coverage
- Host: GitHub
- URL: https://github.com/dominictarr/curry
- Owner: dominictarr
- Archived: true
- Created: 2010-11-29T08:55:50.000Z (almost 14 years ago)
- Default Branch: master
- Last Pushed: 2019-10-08T05:42:09.000Z (about 5 years ago)
- Last Synced: 2024-10-29T21:51:34.810Z (13 days ago)
- Language: JavaScript
- Homepage:
- Size: 38.1 KB
- Stars: 312
- Watchers: 10
- Forks: 19
- Open Issues: 14
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
CURRY
=====
A curry function without anything **too clever**
_(... because hunger is the finest spice)_
[](https://ci.testling.com/hughfdjackson/curry)
# Why
If you don't know currying, or aren't sold on it's awesomeness, perhaps [a friendly blog post](http://hughfdjackson.com/javascript/2013/07/06/why-curry-helps/) will help.
# API
### curry
```javascript
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:
var add1 = add(1);
add1(2) //= 3;
//-- 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:
var zipAdd = zipWith(add);
var zipAddWith123 = zipAdd([1, 2, 3]);
//-- 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
zipAdd.length; //= 2
zipAddWith123.length; //= 1
```
### curry.to
Sometimes it's necessary (especially when wrapping variadic functions) to explicitly provide an arity for your curried function:
```javascript
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
```
### curry.adapt
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:
```javascript
var delve = require('delve');
var delveC = curry.adapt(delve);
var getDataFromResponse = delveC('response.body.data');
getDataFromResponse({ response: { body: { data: { x: 2 }} } }); //= { x: 2 }
```
### curry.adaptTo
Like `curry.adapt`, but the arity explicitly provided:
```javascript
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
```bash
npm install curry
```
### amd
```javascript
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](https://github.com/substack/node-browserify) or [require.js](http://requirejs.org), you can load curry globally:
```html
<!-- curry available here -->
```
∏∏