What is the best pattern for limiting the concurrency of resolving an array
(queue) of promises?  I'd like to have another argument to Q.all (or qq's
queue?) that would allow at most a specified number of the functions being
processed at once.

Here is one solution:
https://github.com/sourcemint/util-js/blob/master/lib/q-throttle.js

Christoph

What you're asking for doesn't really make sense.  An array of promises
(such as that you'd pass to Q.all) is an array of tasks that have already
been started.  Waiting on them to resolve is, to all intents and purposes,
free.  Waiting on them one at a time, versus in parallel has very little
difference (one has slightly fewer turns of the event loop).  It's when you
call the functions that you begin the tasks, so what you really need to do
is throttle how many times you call the function simultaniously:

You could try something like this:

```
function throttle(functions, max) {
  var def = Q.defer();
  var result = [];
  var running = 0;
  var waitingAt;
  function next(i) {
    if (running > max) {
      waitingAt = i;
    } else if (i < functions.length) {
      var res = functions[i]();
      result.push(res);
      res.then(completeTask, completeTask);
    } else {
      def.resolve(Q.all(result));
    }
  }
  next(0);
  function completeTask() {
    if (waitingAt) {
      next(waitingAt);
      waitingAt = null;
    }
  }
  return def.promise;

```

I haven't tested it, but it should take an array of functions and a
max-concurrency value, then execute up to max of them in parallel and
return a promise for an array of the results.

I solved it by using async and creating a queue that promises to give you a
callback to call when you're done.

Coffeescript:
Q = require 'q'
async = require 'async'

promisQue = async.queue(
  (deferred, callback) ->
    deferred.resolve(callback)
  3
)

throttledPromise = () ->
  deferred = Q.defer()
  promisQue.push deferred
  deferred.promise

for i in [1..50]
  ((i) ->
    throttledPromise().then (cb) ->
      setTimeout cb, 500
      console.log i
  )(i)

Javascript:
var Q, async, i, promisQue, throttledPromise, _fn, _i;

Q = require('q');

async = require('async');

promisQue = async.queue(function(deferred, callback) {
  return deferred.resolve(callback);

throttledPromise = function() {
  var deferred;
  deferred = Q.defer();
  promisQue.push(deferred);
  return deferred.promise;

_fn = function(i) {
  return throttledPromise().then(function(cb) {
    setTimeout(cb, 500);
    return console.log(i);
  });
for (i = _i = 1; _i <= 50; i = ++_i) {
  _fn(i);

Thoughts? (the anon (i) function is needed to keep a copy of i for the
promise)

Wout.

Now using a class and showing how to inject another promise:

Q = require 'q'
async = require 'async'

class promisQue
  resolver = (deferred, callback) -> deferred.resolve(callback)

  constructor: (num) ->
    @queue = async.queue resolver, num or 3

  P: () ->
    deferred = Q.defer()
    @queue.push deferred
    deferred.promise

q = new promisQue

lastP = null

for i in [1..20]
  ((i) ->
    lastP = q.P().then (cb) ->
      Q.delay(i, 500).then(-> console.log i).finally cb
  )(i)

lastP.then -> console.log "Done!"