Running Generators

In Chapter 4, we derived a utility called run(..) which can run generators to completion, listening for yielded Promises and using them to async resume the generator. asynquence has just such a utility built in, called runner(..).

Let’s first set up some helpers for illustration:

  1. function doublePr(x) {
  2.     return new Promise( function(resolve,reject){
  3.         setTimeout( function(){
  4.             resolve( x * 2 );
  5.         }, 100 );
  6.     } );
  7. }
  9. function doubleSeq(x) {
  10.     return ASQ( function(done){
  11.         setTimeout( function(){
  12.             done( x * 2)
  13.         }, 100 );
  14.     } );
  15. }

Now, we can use runner(..) as a step in the middle of a sequence:

  1. ASQ( 10, 11 )
  2. .runner( function*(token){
  3.     var x = token.messages[0] + token.messages[1];
  5.     // yield a real promise
  6.     x = yield doublePr( x );
  8.     // yield a sequence
  9.     x = yield doubleSeq( x );
  11.     return x;
  12. } )
  13. .val( function(msg){
  14.     console.log( msg );            // 84
  15. } );

Wrapped Generators

You can also create a self-packaged generator — that is, a normal function that runs your specified generator and returns a sequence for its completion — by ASQ.wrap(..)ing it:

  1. var foo = ASQ.wrap( function*(token){
  2.     var x = token.messages[0] + token.messages[1];
  4.     // yield a real promise
  5.     x = yield doublePr( x );
  7.     // yield a sequence
  8.     x = yield doubleSeq( x );
  10.     return x;
  11. }, { gen: true } );
  13. // ..
  15. foo( 8, 9 )
  16. .val( function(msg){
  17.     console.log( msg );            // 68
  18. } );

There’s a lot more awesome that runner(..) is capable of, but we’ll come back to that in Appendix B.