DEPRECATED: Use small modules instead
Latest commit ff9b069 Feb 20, 2013 @azer Update
Failed to load latest commit information.
lib less params in each.async Aug 19, 2012
.npmignore add npmignore Jun 7, 2012
Makefile Update Feb 20, 2013
package.json less params in each.async Aug 19, 2012

functools is a JavaScript library for functional programming.

Inspired by: Common Lisp, Clojure and Python. Tested on: Chrome, IE6 and Node. (See test/results.json for details)


Function Composition:

var compose = require("functools").compose;

compose(select, update, prettify, display)("body .messages");

Async Function Compositon:

function findFiles(path, callback){  ... }
function readContents(files, callback){ ... }
function upload(files, callback){}

compose.async(findFiles, readContents, upload)('~/messages', function(error, uploadResult){

Async Juxtaposition:

function turkish(word, callback){ /* some magic here */ }
function french(word, callback){ /* some magic here */ }
function polish(word, callback){ /* some magic here */ }

juxt.async({ 'tr': turkish, 'fr': french, 'pl': polish })("hello", function(error,  results){
  assert.equal(, "merhaba");
  assert.equal(, "bonjour");
  assert.equal(, "cześć");


var fn = require("functools");

var pickEvens = fn.curry(fn.filter)(function(num){ return num%2==0 });

pickEvens([3,1,4]) // returns [4]
pickEvens([1,5,9,2,6,5]) // returns [2,6]


$ npm install functools


$ wget



  • each.async
  • memoize
  • memoize.async


  • IE6, IE7 and IE8 bugfixes
  • better testing


compose(functions ...)(value)

Combine functions in a new one, passing the result of each function to next one, from left to right.

function cube(x){ return x*x*x };

compose(Math.sqrt,cube)(4); // returns 8

compose.async(functions ...)(value,callback)

Asynchronous function composition.

var messageTransmission = compose.async(receiveMessage, getUserProfiles, transmitMessage);

messageTransmission({ msg: "Hello!", 'from': 3, 'to': 1 }, function(error, result){

function receiveMessage(msg, callback){}
function getUserProfiles(msg, callback){ ... callback(null, from, to, msg); }
function transmitMessage(from, to, message, callback){}

curry(function, args ...)

Transform multiple-argument function into a chain of functions that return each other until all arguments are gathered.

function sum(x,y){ return x+y; }

var add3 = curry(sum, 3);

add3(14); // returns 17
add3(20); // returns 23


Call function once for each element in iterable.

each(function(el,ind,list){ console.assert( el == list[ind] ); }, [3, 1, 4]);


Call async function once for each element in iterable, and callback after iteration.

> function uploadFile(filename, callback){
  console.log('Uploading ', filename);

> each.async(uploadFile, [ '/docs/intro', '/docs/body', '/docs/outro' ], function(error){

    console.log('Failed to upload files');
    throw error;

  console.log('All files has been uploaded successfully');


> Uploading /docs/intro
Uploading /docs/body
Uploading /docs/outro
All files has been uploaded successfully


Construct a new array from those elements of iterable for which function returns true.

filter(function(el,ind,list){ return el%2==0 }, [3, 1, 4]); // returns [4]

filter.async(function,iterable, callback)

Call async function once for each element in iterable, receiving a boolean parameter, and construct a new array of all the values for which function produces true

var users = [ 3, 5, 8, 13, 21 ]; // only user#3 and user#8 have permission in this example

function hasPermission(userId, callback){ ... callback(/* true or false */); }

filter.async(hasPermission, [3, 1, 4], function(permittedUsers){
  assert.equal(permittedUsers.length, /* ? */);

juxt(functions ...)

Take a set of functions, return a function that is the juxtaposition of those functions. The returned function takes a variable number of arguments and returns a list containing the result of applying each fn to the arguments.

function inc1(n){ return n+1 };
function inc2(n){ return n+2 };
function inc3(n){ return n+3 };

juxt(inc1, inc2, inc3)(314); // returns [315,316,317]

juxt.async(functions ...)

Async implementation of juxt.

function turkish(word, callback){ /* some magic here */ }
function french(word, callback){ /* some magic here */ }
function polish(word, callback){ /* some magic here */ }

juxt.async(turkish, french, polish)("hello", function(error,  results){
  assert.equal(results[0], "merhaba");
  assert.equal(results[1], "bonjour");
  assert.equal(results[2], "cześć");


Invoke function once for each element of iterable. Creates a new iterable containing the values returned by the function.

function square(n){
  return n*n;

map(square, [3,1,4,1,5,9]); // returns [9,1,16,1,25,81]

Objects can be passed as well;

var dict = { 'en':'hello', 'tr': 'merhaba', 'fr':'bonjour' };

function capitalize(str){
  return str.charAt(0).toUpperCase() + str.slice(1);

map(capitalize, dict); // returns { 'en':'Hello', 'tr':'Merhaba', 'fr':'Bonjour' }

map.async(function,iterable, callback)

Apply async function to every item of iterable, receiving a callback function which takes error (if there is) and replacement parameters.

function readFile(id, callback){ ... callback(undefined, data); }

map.async(readFile, ['./foo/bar', './foo/qux', './corge'], function(error, files){
  if(error) throw error;

  console.log(files[0]); // will put the content of ./foo/bar


Return a memoized version of function. hasher is optional.

> function myfunc(n){
    console.log("doing some work");
    return n + 10;

> var myfuncMemo = memoize(myfunc);
> myfuncMemo(1);
"doing some work"
> myfuncMemo(1);
> myfuncMemo(20);
"doing some work"
> myfuncMemo(20);

memoize.async(function, hasher)

Memoize given async function if it doesn't produce any error.

> function readFile(){ console.log('doing some work'); ... callback(undefined, buffer); }

> var readFileMemo = memoize.async(readFile);

> readFileMemo('/docs/readme', function(error, content){
"doing some work"

> "This is the Readme file"

> readFileMemo('/docs/readme', function(error, content){
"This is the Readme file"

partial(function,initial arguments,*context *)

Return a new function which will call function with the gathered arguments.

function testPartial(){
  var args = reduce(function(x,y){ return x+", "+y },arguments);


partial(testPartial, [3,14], 3.14159)(1,5,9);

The example code above will output:

this: 3.14159
args: 3,14,1,5,9


Apply function cumulatively to the items of iterable, as to reduce the iterable to a single value

reduce(function(x,y){ return x*y }, [3,1,4]); // returns 12

reduce.async(function,iterable, callback)

Async implementation of reduce.

var users = [2, 3, 5, 8, 13];

function usernames(accum, userId){ ... callback(undefined, accum + ', ' + username); }

reduce.async(usernames, users, function(error, result){
  if(error) throw error;

  console.log(result); // foo, bar, qux ...


On NodeJS:

$ npm test

On Browsers

Run make test command to publish the tests on localhost:1314. Visit the URL using the browser on which you want to run the tests. Stop the server (Ctrl+C) when you're done with testing.

To see the summary of results;

$ make test do=verify
Not Tested: firefox, ie8, ie7
Passed: ie6, webkit

Revision: 1.3.0
Results Source: test/results.json
Config: test/config.json