use parallelOf/seriesOf functions internally

1 files changed, 21 insertions, 27 deletions

diff --git a/lib/async.js b/lib/async.js
index 8f3903d..5cbdf84 100644
--- a/lib/async.js
+++ b/lib/async.js
@@ -188,7 +188,7 @@
 
     async.forEachLimit =
     async.eachLimit = function (arr, limit, iterator, callback) {
-        var fn = _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
+        return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
     };
 
     function _eachLimit(limit) {
@@ -356,12 +356,6 @@
             return fn.apply(null, [async.each].concat(args));
         };
     }
-    function doParallelLimit(limit, fn) {
-        return function () {
-            var args = _baseSlice(arguments);
-            return fn.apply(null, [_eachLimit(limit)].concat(args));
-        };
-    }
     function doSeries(fn) {
         return function () {
             var args = _baseSlice(arguments);
@@ -436,14 +430,14 @@
         arr = _map(arr, function (x, i) {
             return {index: i, value: x};
         });
-        eachfn(arr, function (x, callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x.value, function (v) {
                 if (v) {
                     results.push(x);
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             callback(_map(results.sort(function (a, b) {
                 return a.index - b.index;
             }), function (x) {
@@ -453,24 +447,24 @@
     }
 
     async.select =
-    async.filter = doParallel(_filter);
+    async.filter = doParallelOf(_filter);
 
     async.selectSeries =
-    async.filterSeries = doSeries(_filter);
+    async.filterSeries = doSeriesOf(_filter);
 
     function _reject(eachfn, arr, iterator, callback) {
         var results = [];
         arr = _map(arr, function (x, i) {
             return {index: i, value: x};
         });
-        eachfn(arr, function (x, callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x.value, function (v) {
                 if (!v) {
                     results.push(x);
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             callback(_map(results.sort(function (a, b) {
                 return a.index - b.index;
             }), function (x) {
@@ -478,11 +472,11 @@
             }));
         });
     }
-    async.reject = doParallel(_reject);
-    async.rejectSeries = doSeries(_reject);
+    async.reject = doParallelOf(_reject);
+    async.rejectSeries = doSeriesOf(_reject);
 
     function _detect(eachfn, arr, iterator, main_callback) {
-        eachfn(arr, function (x, callback) {
+        eachfn(arr, function (x, index, callback) {
             iterator(x, function (result) {
                 if (result) {
                     main_callback(x);
@@ -492,12 +486,12 @@
                     callback();
                 }
             });
-        }, function (err) {
+        }, function () {
             main_callback();
         });
     }
-    async.detect = doParallel(_detect);
-    async.detectSeries = doSeries(_detect);
+    async.detect = doParallelOf(_detect);
+    async.detectSeries = doSeriesOf(_detect);
 
     async.any =
     async.some = function (arr, iterator, main_callback) {
@@ -509,7 +503,7 @@
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             main_callback(false);
         });
     };
@@ -524,7 +518,7 @@
                 }
                 callback();
             });
-        }, function (err) {
+        }, function () {
             main_callback(true);
         });
     };
@@ -815,18 +809,18 @@
     };
 
     function _concat(eachfn, arr, fn, callback) {
-        var r = [];
-        eachfn(arr, function (x, cb) {
+        var result = [];
+        eachfn(arr, function (x, index, cb) {
             fn(x, function (err, y) {
-                r = r.concat(y || []);
+                result = result.concat(y || []);
                 cb(err);
             });
         }, function (err) {
-            callback(err, r);
+            callback(err, result);
         });
     }
-    async.concat = doParallel(_concat);
-    async.concatSeries = doSeries(_concat);
+    async.concat = doParallelOf(_concat);
+    async.concatSeries = doSeriesOf(_concat);
 
     async.whilst = function (test, iterator, callback) {
         if (test()) {