co

Generator based control flow goodness for nodejs and the browser, using promises, letting you write non-blocking code in a nice-ish way.

co@4.0.0 has been released, which now relies on promises. It is a stepping stone towards the async/await proposal. The primary API change is how co() is invoked. Before, co returned a "thunk", which you then called with a callback and optional arguments. Now, co() returns a promise.

co(function*(){varresult=yieldPromise.resolve(true);returnresult;}).then(function(value){console.log(value);},function(err){console.error(err.stack);});

If you want to convert a co-generator-function into a regular function that returns a promise, you now use co.wrap(fn*).

varfn=co.wrap(function*(val){returnyieldPromise.resolve(val);});fn(true).then(function(val){});

co@4+ requires a Promise implementation. For versions of node < 0.11 and for many older browsers, you should/must include your own Promise polyfill.

When using node 0.10.x and lower or browsers without generator support, you must use gnode and/or regenerator.

When using node 0.11.x, you must use the --harmony-generators flag or just --harmony to get access to generators.

Node v4+ is supported out of the box, you can use co without flags or polyfills.

$ npm install co

Any library that returns promises work well with co.

• mz - wrap all of node's code libraries as promises.

View the wiki for more libraries.

varco=require('co');co(function*(){// yield any promisevarresult=yieldPromise.resolve(true);}).catch(onerror);co(function*(){// resolve multiple promises in parallelvara=Promise.resolve(1);varb=Promise.resolve(2);varc=Promise.resolve(3);varres=yield[a,b,c];console.log(res);// => [1, 2, 3]}).catch(onerror);// errors can be try/catchedco(function*(){try{yieldPromise.reject(newError('boom'));}catch(err){console.error(err.message);// "boom"}}).catch(onerror);functiononerror(err){// log any uncaught errors// co will not throw any errors you do not handle!!!// HANDLE ALL YOUR ERRORS!!!console.error(err.stack);}

The yieldable objects currently supported are:

• promises
• thunks (functions)
• array (parallel execution)
• objects (parallel execution)
• generators (delegation)
• generator functions (delegation)

Nested yieldable objects are supported, meaning you can nest promises within objects within arrays, and so on!

Read more on promises!

Thunks are functions that only have a single argument, a callback. Thunk support only remains for backwards compatibility and may be removed in future versions of co.

yielding an array will resolve all the yieldables in parallel.

co(function*(){varres=yield[Promise.resolve(1),Promise.resolve(2),Promise.resolve(3),];console.log(res);// => [1, 2, 3]}).catch(onerror);

Just like arrays, objects resolve all yieldables in parallel.

co(function*(){varres=yield{1: Promise.resolve(1),2: Promise.resolve(2),};console.log(res);// => { 1: 1, 2: 2 }}).catch(onerror);

Any generator or generator function you can pass into co can be yielded as well. This should generally be avoided as we should be moving towards spec-compliant Promises instead.

Returns a promise that resolves a generator, generator function, or any function that returns a generator.

co(function*(){returnyieldPromise.resolve(true);}).then(function(val){console.log(val);},function(err){console.error(err.stack);});

Convert a generator into a regular function that returns a Promise.

varfn=co.wrap(function*(val){returnyieldPromise.resolve(val);});fn(true).then(function(val){});

MIT