Possible internal interface update

[charlierudolph]

Instead of having three functions

each(arr, iterator, [callback])
eachSeries(arr, iterator, [callback])
eachLimit(arr, limit, iterator, [callback])

How about just having each take an optional object argument at the end

each(arr, iterator[, options][, callback])

To run series have options be {series: true}
To run with limit have options be {limit: 2}

The series option could even be removed as its equivalent to {limit: 1}

I think this would help simplify the library as the number of functions will be reduced but the power will still be there and additional options can easily be added.

This could be done as a non-breaking change as eachSeries and eachLimit are deprecated and each is extended to support the optional options argument.

[aearly]

I'm not really interested in changing the API right now, but you do have a very interesting observation that each and eachSeries are really just special cases of eachLimit.

each = (arr, iterator, cb) => eachLimit(arr, Infinity, iterator, cb)
eachSeries = (arr, iterator, cb) => eachLimit(arr, 1, iterator, cb) 

We could simplify our internals if we implemented each and eachSeries in terms of eachLimit, but I'd watch for performance regressions.

[aearly]

A quick test reveals that the performance impact is negligible, but it changes the behavior of the functions subtly in ways that cause tests to break. I really like the simplification, but this would be a v2 change.

[kobezzza]

I think that methods during and doDuring much better implement as an optional feature of whilst/doWhilst/until/doUntil.

Sync API

var count = 0;
async.whilst(
    function () { return count < 5; },
    function (callback) {
        count++;
        setTimeout(callback, 1000);
    },
    function (err) {}
);

Async API

var count = 0;
async.whilst(
    // Just check that arguments.length > 0
    function (callback) {
      return callback(null, count < 5);
    },
    function (callback) {
        count++;
        setTimeout(callback, 1000);
    },
    function (err) {}
);

[aearly]

Relying on the arity of the function is too brittle -- functions with optional args won't have an accurate length, nor will partially applied functions. Also, in the case of doUntil, doDuring, and doWhilst, the results of the async function are passed to the test function, so length checking doesn't work at all for those.

[megawac]

👍

[charlierudolph]

Has anyone started working on this? I'm happy to take this on.

[aearly]

Go for it. I also just created a 2.x branch for things we're tracking for
that release.