Control flow ala ES7 async/await using ES6 generator (thanks to tj/co) with async.js (v2) signatures



Motivation

async-co provide javascript async/await (through ES6 generator & co) equivalent signatures of the excellent async workflow library.


Module are exported in standard commonJS module format and written in pure ES5/ES6 strict format. (no transpilation required nor used).
Use browserify if you need async-co modules in a browser environnement.


async-co is not a wrapper on async, but rather leverages the full potential of native async/await & promises contract. Code tend to be small & very efficient (far more simplier than using callbacks), just give async-co/queue.js a look

Addition to the async library signatures / promise pooling

* Generator cannot use arrow function binding style, yet it might be usefull to bind async-co closure, therefore, you can use an extra optional args to all signature to set generator binding context. (i.e. as in native .forEach )
* Per design, it's easy to "throttle" a function that return a Promise ; checkout the "throttle" API for a way to make an ultra simple http request pooling.
* async logic allow async/each to iterate through array AND objects. Per design sanify, async-co does not. Use each/eachLimit/eachSeries for array, eachOf/eachOfLimit/eachOfSeries for collections.

API

async-co/eachLimit(arr, concurrency, *thunk [, thisobj])

Nothing special here

async-co/eachSeries(arr, *thunk [, thisobj] )

// = eachLimit concurrency = 1

async-co/each(arr, *thunk [, thisobj])

// = eachLimit concurrency = arr.length

async-co/eachOfLimit (dict, concurrency, *thunk [, thisobj])

Nothing special here neither

async-co/eachOfSeries(dict, *thunk [, thisobj])

// = eachOfLimit concurrency = 1

async-co/eachOf(dict, *thunk [, thisobj])

// = eachOfLimit concurrency = dict.length


``
const eachLimit = require('async-co/eachLimit');

co(function *() {

var stuffs = [1,2,3, 5, 7]

yield eachLimit(stuffs, 2, function*(id){
yield dootherStuffs(id);
});

});
`

async-co/setImmediate(fn)

Call a function in javascript next tick (using setImmediate API, or timeout 0 pollyfill)

q = async-co/queue(*thunk, concurrency)

Return a QueueObject you can push task into.

$3

Wait for thunk to process task (wait for worker, if needed)

`
const queue = require('async-co/queue');
const fetch = require('node-fetch');

var q = queue(fetch, 1); //let's be nice

co(function *() {
yield q.push("http://example.com/stuff.json");
});

co(function *() {
yield q.push("http://example.com/otherstuff.json"); //will wait for stuff to be retrieved
});
`

async-co/throttle

Throttle any function that return a promise, sugar syntax helper for async-co/queue


`
const throttle = require('async-co/throttle');
var fetch = require('node-fetch');
fetch = throttle(fetch, 1); //make fetch behave nicely

co(function *() {
yield fetch("http://example.com/stuff.json");
});

co(function *() {
yield fetch("http://example.com/otherstuff.json"); //will wait for stuff.json to be retrieved
});
``

Tests

async-co is tested against async test suite.

TODO

* Get rich or die tryin'
* write a working async-co/cargo (see the challenge on stackoverflow)

Credits

* 131
* not dependant upon, yet relying on co
* inspired from the excellent async

Alternatives / relatives

* koa-async ; a clever Promisify wrapper on top of async (but not leveraging the full potential of ES7 async/await capabilities)
* caolan/async/asyncify.js goes the same as koa-async.
* es6-promise-pool ; equivalent to async-co/queue, with a different API

Shoutbox, keywords, SEO love

async/await, ES6 generators, co, async-co, promise, Promises, yield, async, queue, map, throttle, "Let's have a beer & talk in Paris"