Optimized waterfall, parallel, et al.

lib/auto.js

@@ -4,7 +4,7 @@ import indexOf from 'lodash/_baseIndexOf';
 import isArray from 'lodash/isArray';
 import okeys from 'lodash/keys';
 import noop from 'lodash/noop';
-import rest from './internal/rest';
+import slice from 'lodash/slice';
 
 import once from './internal/once';
 import onlyOnce from './internal/onlyOnce';
@@ -192,26 +192,26 @@ export default function (tasks, concurrency, callback) {
     function runTask(key, task) {
         if (hasError) return;
 
-        var taskCallback = onlyOnce(rest(function(err, args) {
+        var taskCallback = onlyOnce(function(err, result) {
             runningTasks--;
-            if (args.length <= 1) {
-                args = args[0];
+            if (arguments.length > 2) {
+                result = slice(arguments, 1);
             }
             if (err) {
                 var safeResults = {};
                 forOwn(results, function(val, rkey) {
                     safeResults[rkey] = val;
                 });
-                safeResults[key] = args;
+                safeResults[key] = result;
                 hasError = true;
                 listeners = Object.create(null);
 
                 callback(err, safeResults);
             } else {
-                results[key] = args;
+                results[key] = result;
                 taskComplete(key);
             }
-        }));
+        });
 
         runningTasks++;
         var taskFn = wrapAsync(task[task.length - 1]);

lib/doDuring.js

@@ -1,5 +1,5 @@
 import noop from 'lodash/noop';
-import rest from './internal/rest';
+import slice from './internal/slice';
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
 
@@ -28,11 +28,12 @@ export default function doDuring(fn, test, callback) {
     var _fn = wrapAsync(fn);
     var _test = wrapAsync(test);
 
-    var next = rest(function(err, args) {
-        if (err)  return callback(err);
+    function next(err/*, args...*/) {
+        if (err) return callback(err);
+        var args = slice(arguments, 1);
         args.push(check);
         _test.apply(this, args);
-    });
+    };
 
     function check(err, truth) {
         if (err) return callback(err);

lib/doWhilst.js

@@ -1,5 +1,5 @@
 import noop from 'lodash/noop';
-import rest from './internal/rest';
+import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -29,10 +29,11 @@ import wrapAsync from './internal/wrapAsync';
 export default function doWhilst(iteratee, test, callback) {
     callback = onlyOnce(callback || noop);
     var _iteratee = wrapAsync(iteratee);
-    var next = rest(function(err, args) {
+    var next = function(err/*, args...*/) {
         if (err) return callback(err);
+        var args = slice(arguments, 1);
         if (test.apply(this, args)) return _iteratee(next);
         callback.apply(null, [null].concat(args));
-    });
+    };
     _iteratee(next);
 }

lib/internal/parallel.js

@@ -1,20 +1,20 @@
 import noop from 'lodash/noop';
 import isArrayLike from 'lodash/isArrayLike';
-import rest from './rest';
+import slice from './slice';
 import wrapAsync from './wrapAsync';
 
 export default function _parallel(eachfn, tasks, callback) {
     callback = callback || noop;
     var results = isArrayLike(tasks) ? [] : {};
 
     eachfn(tasks, function (task, key, callback) {
-        wrapAsync(task)(rest(function (err, args) {
-            if (args.length <= 1) {
-                args = args[0];
+        wrapAsync(task)(function (err, result) {
+            if (arguments.length > 2) {
+                result = slice(arguments, 1);
             }
-            results[key] = args;
+            results[key] = result;
             callback(err);
-        }));
+        });
     }, function (err) {
         callback(err, results);
     });

lib/internal/slice.js

@@ -0,0 +1,9 @@
+export default function slice(arrayLike, start) {
+    start = start|0;
+    var newLen = Math.max(arrayLike.length - start, 0);
+    var newArr = Array(newLen);
+    for(var idx = 0; idx < newLen; idx++)  {
+        newArr[idx] = arrayLike[start + idx];
+    }
+    return newArr;
+}

lib/reflect.js

@@ -1,5 +1,5 @@
 import initialParams from './internal/initialParams';
-import rest from './internal/rest';
+import slice from './internal/slice';
 import wrapAsync from './internal/wrapAsync';
 
 /**
@@ -44,23 +44,19 @@ import wrapAsync from './internal/wrapAsync';
 export default function reflect(fn) {
     var _fn = wrapAsync(fn);
     return initialParams(function reflectOn(args, reflectCallback) {
-        args.push(rest(function callback(err, cbArgs) {
+        args.push(function callback(err, cbArg) {
             if (err) {
                 reflectCallback(null, {
                     error: err
                 });
             } else {
-                var value = null;
-                if (cbArgs.length === 1) {
-                    value = cbArgs[0];
-                } else if (cbArgs.length > 1) {
-                    value = cbArgs;
-                }
+                var value = cbArg;
+                if (arguments.length > 2) value = slice(arguments, 1);
                 reflectCallback(null, {
                     value: value
                 });
             }
-        }));
+        });
 
         return _fn.apply(this, args);
     });

lib/seq.js

@@ -1,5 +1,6 @@
 import noop from 'lodash/noop';
 import rest from './internal/rest';
+import slice from 'lodash/slice';
 import reduce from './reduce';
 import wrapAsync from './internal/wrapAsync';
 import arrayMap from 'lodash/_arrayMap';
@@ -55,9 +56,10 @@ export default rest(function seq(functions) {
         }
 
         reduce(_functions, args, function(newargs, fn, cb) {
-            fn.apply(that, newargs.concat(rest(function(err, nextargs) {
+            fn.apply(that, newargs.concat(function(err/*, nextargs...*/) {
+                var nextargs = slice(arguments, 1);
                 cb(err, nextargs);
-            })));
+            }));
         },
         function(err, results) {
             cb.apply(that, [err].concat(results));

lib/waterfall.js

@@ -1,7 +1,7 @@
 import isArray from 'lodash/isArray';
 import noop from 'lodash/noop';
 import once from './internal/once';
-import rest from './internal/rest';
+import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -74,12 +74,13 @@ export default  function(tasks, callback) {
             return callback.apply(null, [null].concat(args));
         }
 
-        var taskCallback = onlyOnce(rest(function(err, args) {
+        var taskCallback = onlyOnce(function(err/*, cbArgs...*/) {
+            var cbArgs = slice(arguments, 1);
             if (err) {
-                return callback.apply(null, [err].concat(args));
+                return callback.apply(null, [err].concat(cbArgs));
             }
-            nextTask(args);
-        }));
+            nextTask(cbArgs);
+        });
 
         args.push(taskCallback);
 

lib/whilst.js

@@ -1,5 +1,5 @@
 import noop from 'lodash/noop';
-import rest from './internal/rest';
+import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -42,10 +42,10 @@ export default function whilst(test, iteratee, callback) {
     callback = onlyOnce(callback || noop);
     var _iteratee = wrapAsync(iteratee);
     if (!test()) return callback(null);
-    var next = rest(function(err, args) {
+    var next = function(err/*, args...*/) {
         if (err) return callback(err);
         if (test()) return _iteratee(next);
-        callback.apply(null, [null].concat(args));
-    });
+        callback.apply(null, [null].concat(slice(arguments, 1)));
+    };
     _iteratee(next);
 }

perf/suites.js

@@ -233,6 +233,28 @@ module.exports = [{
     fn: function(async, done) {
         async.waterfall(tasks, done);
     }
+}, {
+    name: "auto",
+    args: [
+        [5],
+        [10],
+        [100]
+    ],
+    setup: function setup(count) {
+        tasks = {
+            dep1: function (cb) { cb(null, 1); }
+        };
+        _.times(count, function(n) {
+            var task = ['dep' + (n+1), function(results, cb) {
+                setImmediate(cb, null, n);
+            }];
+            if (n > 2) task.unshift('dep' + n);
+            tasks['dep' + (n+2)] = task;
+        });
+    },
+    fn: function(async, done) {
+        async.auto(tasks, done);
+    }
 }, {
     name: "queue",
     args: [