feat: await-able Async methods (#1572)

* make each and family awaitable

* dont pretend they're AsyncFunctions

* check errors

* ensure function name is preserved somehow

* awaitable concat

* awaitable detect

* awaitable every/filter

* awaitable groupBy

* awaitable map/mapValues

* awaitable reduce

* awaitable reject

* awaitable some

* awaitable transform

* awaitable times

* awaitable auto

* awaitable compose/seq

* awaitable whilst/until (lol)

* awaitable forever

* awaitable parallel/race

* awaitable retry

* awaitable series (lol)

* awaitable tryEach

* awaitable waterfall (lol)

* lint

* cleanup, remove noop and unused internal functions

74 files changed, 404 insertions, 200 deletions

diff --git a/lib/auto.js b/lib/auto.js
index b06e3c5..ad92d74 100644
--- a/lib/auto.js
+++ b/lib/auto.js
@@ -1,8 +1,7 @@
-import noop from './internal/noop';
-
 import once from './internal/once';
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
+import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback'
 
 /**
  * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on
@@ -42,7 +41,7 @@ import wrapAsync from './internal/wrapAsync';
  * pass an error to their callback. Results are always returned; however, if an
  * error occurs, no further `tasks` will be performed, and the results object
  * will only contain partial results. Invoked with (err, results).
- * @returns undefined
+ * @returns {Promise} a promise, if a callback is not passed
  * @example
  *
  * async.auto({
@@ -83,13 +82,13 @@ import wrapAsync from './internal/wrapAsync';
  *     console.log('results = ', results);
  * });
  */
-export default function (tasks, concurrency, callback) {
-    if (typeof concurrency === 'function') {
+export default function auto(tasks, concurrency, callback) {
+    if (typeof concurrency !== 'number') {
         // concurrency is optional, shift the args.
         callback = concurrency;
         concurrency = null;
     }
-    callback = once(callback || noop);
+    callback = once(callback || promiseCallback());
     var numTasks = Object.keys(tasks).length;
     if (!numTasks) {
         return callback(null);
@@ -251,4 +250,6 @@ export default function (tasks, concurrency, callback) {
         });
         return result;
     }
+
+    return callback[PROMISE_SYMBOL]
 }
diff --git a/lib/autoInject.js b/lib/autoInject.js
index 004cfda..996fceb 100644
--- a/lib/autoInject.js
+++ b/lib/autoInject.js
@@ -54,6 +54,7 @@ function parseParams(func) {
  * the tasks have been completed. It receives the `err` argument if any `tasks`
  * pass an error to their callback, and a `results` object with any completed
  * task results, similar to `auto`.
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * //  The example from `auto` can be rewritten as follows:
@@ -142,5 +143,5 @@ export default function autoInject(tasks, callback) {
         }
     });
 
-    auto(newTasks, callback);
+    return auto(newTasks, callback);
 }
diff --git a/lib/compose.js b/lib/compose.js
index 1706013..ea97c43 100644
--- a/lib/compose.js
+++ b/lib/compose.js
@@ -6,6 +6,9 @@ import seq from './seq';
  * follows. Composing functions `f()`, `g()`, and `h()` would produce the result
  * of `f(g(h()))`, only this version uses callbacks to obtain the return values.
  *
+ * If the last argument to the composed function is not a function, a promise
+ * is returned when you call it.
+ *
  * Each function is executed with the `this` binding of the composed function.
  *
  * @name compose
@@ -35,6 +38,6 @@ import seq from './seq';
  *     // result now equals 15
  * });
  */
-export default function(...args) {
+export default function compose(...args) {
     return seq(...args.reverse());
 }
diff --git a/lib/concat.js b/lib/concat.js
index 0a8251a..394e3c2 100644
--- a/lib/concat.js
+++ b/lib/concat.js
@@ -1,5 +1,5 @@
-import doLimit from './internal/doLimit';
 import concatLimit from './concatLimit';
+import awaitify from './internal/awaitify'
 
 /**
  * Applies `iteratee` to each item in `coll`, concatenating the results. Returns
@@ -15,14 +15,18 @@ import concatLimit from './concatLimit';
  * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
  * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,
  * which should use an array as its result. Invoked with (item, callback).
- * @param {Function} [callback(err)] - A callback which is called after all the
+ * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished, or an error occurs. Results is an array
  * containing the concatenated results of the `iteratee` function. Invoked with
  * (err, results).
+ * @returns A Promise, if no callback is passed
  * @example
  *
  * async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
  *     // files is now a list of filenames that exist in the 3 directories
  * });
  */
-export default doLimit(concatLimit, Infinity);
+function concat(coll, iteratee, callback) {
+    return concatLimit(coll, Infinity, iteratee, callback)
+}
+export default awaitify(concat, 3);
diff --git a/lib/concatLimit.js b/lib/concatLimit.js
index 5dbbe8d..34c35df 100644
--- a/lib/concatLimit.js
+++ b/lib/concatLimit.js
@@ -1,6 +1,6 @@
-import noop from './internal/noop';
 import wrapAsync from './internal/wrapAsync';
 import mapLimit from './mapLimit';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`concat`]{@link module:Collections.concat} but runs a maximum of `limit` async operations at a time.
@@ -19,11 +19,11 @@ import mapLimit from './mapLimit';
  * `iteratee` functions have finished, or an error occurs. Results is an array
  * containing the concatenated results of the `iteratee` function. Invoked with
  * (err, results).
+ * @returns A Promise, if no callback is passed
  */
-export default function(coll, limit, iteratee, callback) {
-    callback = callback || noop;
+function concatLimit(coll, limit, iteratee, callback) {
     var _iteratee = wrapAsync(iteratee);
-    mapLimit(coll, limit, (val, iterCb) => {
+    return mapLimit(coll, limit, (val, iterCb) => {
         _iteratee(val, (err, ...args) => {
             if (err) return iterCb(err);
             return iterCb(null, args);
@@ -39,3 +39,4 @@ export default function(coll, limit, iteratee, callback) {
         return callback(err, result);
     });
 }
+export default awaitify(concatLimit, 4)
diff --git a/lib/concatSeries.js b/lib/concatSeries.js
index ae1bd67..0b36803 100644
--- a/lib/concatSeries.js
+++ b/lib/concatSeries.js
@@ -1,5 +1,5 @@
-import doLimit from './internal/doLimit';
 import concatLimit from './concatLimit';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.
@@ -14,9 +14,13 @@ import concatLimit from './concatLimit';
  * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`.
  * The iteratee should complete with an array an array of results.
  * Invoked with (item, callback).
- * @param {Function} [callback(err)] - A callback which is called after all the
+ * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished, or an error occurs. Results is an array
  * containing the concatenated results of the `iteratee` function. Invoked with
  * (err, results).
+ * @returns A Promise, if no callback is passed
  */
-export default doLimit(concatLimit, 1);
+function concatSeries(coll, iteratee, callback) {
+    return concatLimit(coll, 1, iteratee, callback)
+}
+export default awaitify(concatSeries, 3);
diff --git a/lib/detect.js b/lib/detect.js
index 3e28f0e..4a6746a 100644
--- a/lib/detect.js
+++ b/lib/detect.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallel from './internal/doParallel';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * Returns the first value in `coll` that passes an async truth test. The
@@ -26,6 +27,7 @@ import doParallel from './internal/doParallel';
  * Result will be the first item in the array that passes the truth test
  * (iteratee) or the value `undefined` if none passed. Invoked with
  * (err, result).
+ * @returns A Promise, if no callback is passed
  * @example
  *
  * async.detect(['file1','file2','file3'], function(filePath, callback) {
@@ -36,4 +38,7 @@ import doParallel from './internal/doParallel';
  *     // result now equals the first file in the list that exists
  * });
  */
-export default doParallel(createTester(bool => bool, (res, item) => item));
+function detect(coll, iteratee, callback) {
+    return createTester(bool => bool, (res, item) => item)(eachOf, coll, iteratee, callback)
+}
+export default awaitify(detect, 3)
diff --git a/lib/detectLimit.js b/lib/detectLimit.js
index a0f9d89..7630d6d 100644
--- a/lib/detectLimit.js
+++ b/lib/detectLimit.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallelLimit from './internal/doParallelLimit';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a
@@ -22,5 +23,9 @@ import doParallelLimit from './internal/doParallelLimit';
  * Result will be the first item in the array that passes the truth test
  * (iteratee) or the value `undefined` if none passed. Invoked with
  * (err, result).
+ * @returns a Promise if no callback is passed
  */
-export default doParallelLimit(createTester(bool => bool, (res, item) => item));
+function detectLimit(coll, limit, iteratee, callback) {
+    return createTester(bool => bool, (res, item) => item)(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(detectLimit, 4)
diff --git a/lib/detectSeries.js b/lib/detectSeries.js
index f563eae..e85c4f8 100644
--- a/lib/detectSeries.js
+++ b/lib/detectSeries.js
@@ -1,5 +1,6 @@
-import detectLimit from './detectLimit';
-import doLimit from './internal/doLimit';
+import createTester from './internal/createTester'
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.
@@ -20,5 +21,10 @@ import doLimit from './internal/doLimit';
  * Result will be the first item in the array that passes the truth test
  * (iteratee) or the value `undefined` if none passed. Invoked with
  * (err, result).
+ * @returns a Promise if no callback is passed
  */
-export default doLimit(detectLimit, 1);
+function detectSeries(coll, iteratee, callback) {
+    return createTester(bool => bool, (res, item) => item)(eachOfLimit(1), coll, iteratee, callback)
+}
+
+export default awaitify(detectSeries, 3)
diff --git a/lib/doUntil.js b/lib/doUntil.js
index d2e5b04..a484df6 100644
--- a/lib/doUntil.js
+++ b/lib/doUntil.js
@@ -20,10 +20,11 @@ import wrapAsync from './internal/wrapAsync';
  * function has passed and repeated execution of `iteratee` has stopped. `callback`
  * will be passed an error and any arguments passed to the final `iteratee`'s
  * callback. Invoked with (err, [results]);
+ * @returns {Promise} a promise, if no callback is passed
  */
 export default function doUntil(iteratee, test, callback) {
     const _test = wrapAsync(test)
-    doWhilst(iteratee, (...args) => {
+    return doWhilst(iteratee, (...args) => {
         const cb = args.pop()
         _test(...args, (err, truth) => cb (err, !truth))
     }, callback);
diff --git a/lib/doWhilst.js b/lib/doWhilst.js
index b3d52a5..3d9a1af 100644
--- a/lib/doWhilst.js
+++ b/lib/doWhilst.js
@@ -1,7 +1,6 @@
-import noop from './internal/noop';
-
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in
@@ -24,10 +23,10 @@ import wrapAsync from './internal/wrapAsync';
  * function has failed and repeated execution of `iteratee` has stopped.
  * `callback` will be passed an error and any arguments passed to the final
  * `iteratee`'s callback. Invoked with (err, [results]);
- * @return undefined
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default function doWhilst(iteratee, test, callback) {
-    callback = onlyOnce(callback || noop);
+function doWhilst(iteratee, test, callback) {
+    callback = onlyOnce(callback);
     var _fn = wrapAsync(iteratee);
     var _test = wrapAsync(test);
     var results
@@ -48,3 +47,5 @@ export default function doWhilst(iteratee, test, callback) {
 
     return check(null, true);
 }
+
+export default awaitify(doWhilst, 3)
diff --git a/lib/each.js b/lib/each.js
index dc856ac..7f6e689 100644
--- a/lib/each.js
+++ b/lib/each.js
@@ -1,6 +1,7 @@
 import eachOf from './eachOf';
 import withoutIndex from './internal/withoutIndex';
 import wrapAsync from './internal/wrapAsync'
+import awaitify from './internal/awaitify'
 
 /**
  * Applies the function `iteratee` to each item in `coll`, in parallel.
@@ -25,6 +26,7 @@ import wrapAsync from './internal/wrapAsync'
  * If you need the index, use `eachOf`.
  * @param {Function} [callback] - A callback which is called when all
  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  * @example
  *
  * // assuming openFiles is an array of file names and saveFile is a function
@@ -59,6 +61,8 @@ import wrapAsync from './internal/wrapAsync'
  *     }
  * });
  */
-export default function eachLimit(coll, iteratee, callback) {
-    eachOf(coll, withoutIndex(wrapAsync(iteratee)), callback);
+function eachLimit(coll, iteratee, callback) {
+    return eachOf(coll, withoutIndex(wrapAsync(iteratee)), callback);
 }
+
+export default awaitify(eachLimit, 3)
diff --git a/lib/eachLimit.js b/lib/eachLimit.js
index e4d67cb..5c491e8 100644
--- a/lib/eachLimit.js
+++ b/lib/eachLimit.js
@@ -1,6 +1,7 @@
 import eachOfLimit from './internal/eachOfLimit';
 import withoutIndex from './internal/withoutIndex';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.
@@ -21,7 +22,9 @@ import wrapAsync from './internal/wrapAsync';
  * Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called when all
  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  */
-export default function eachLimit(coll, limit, iteratee, callback) {
-    eachOfLimit(limit)(coll, withoutIndex(wrapAsync(iteratee)), callback);
+function eachLimit(coll, limit, iteratee, callback) {
+    return eachOfLimit(limit)(coll, withoutIndex(wrapAsync(iteratee)), callback);
 }
+export default awaitify(eachLimit, 4)
diff --git a/lib/eachOf.js b/lib/eachOf.js
index 070204b..0b847ae 100644
--- a/lib/eachOf.js
+++ b/lib/eachOf.js
@@ -1,15 +1,14 @@
 import isArrayLike from './internal/isArrayLike';
 import breakLoop from './internal/breakLoop';
 import eachOfLimit from './eachOfLimit';
-import doLimit from './internal/doLimit';
-import noop from './internal/noop';
 import once from './internal/once';
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 // eachOf implementation optimized for array-likes
 function eachOfArrayLike(coll, iteratee, callback) {
-    callback = once(callback || noop);
+    callback = once(callback);
     var index = 0,
         completed = 0,
         {length} = coll,
@@ -36,7 +35,9 @@ function eachOfArrayLike(coll, iteratee, callback) {
 }
 
 // a generic version of eachOf which can handle array, object, and iterator cases.
-var eachOfGeneric = doLimit(eachOfLimit, Infinity);
+function eachOfGeneric (coll, iteratee, callback) {
+    return eachOfLimit(coll, Infinity, iteratee, callback);
+}
 
 /**
  * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
@@ -56,6 +57,7 @@ var eachOfGeneric = doLimit(eachOfLimit, Infinity);
  * Invoked with (item, key, callback).
  * @param {Function} [callback] - A callback which is called when all
  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  * @example
  *
  * var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
@@ -77,7 +79,9 @@ var eachOfGeneric = doLimit(eachOfLimit, Infinity);
  *     doSomethingWith(configs);
  * });
  */
-export default function(coll, iteratee, callback) {
+function eachOf(coll, iteratee, callback) {
     var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
-    eachOfImplementation(coll, wrapAsync(iteratee), callback);
+    return eachOfImplementation(coll, wrapAsync(iteratee), callback);
 }
+
+export default awaitify(eachOf, 3)
diff --git a/lib/eachOfLimit.js b/lib/eachOfLimit.js
index f439be6..f65d7d1 100644
--- a/lib/eachOfLimit.js
+++ b/lib/eachOfLimit.js
@@ -1,5 +1,6 @@
 import _eachOfLimit from './internal/eachOfLimit';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
@@ -20,7 +21,10 @@ import wrapAsync from './internal/wrapAsync';
  * Invoked with (item, key, callback).
  * @param {Function} [callback] - A callback which is called when all
  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  */
-export default function eachOfLimit(coll, limit, iteratee, callback) {
-    _eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
+function eachOfLimit(coll, limit, iteratee, callback) {
+    return _eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
 }
+
+export default awaitify(eachOfLimit, 4)
diff --git a/lib/eachOfSeries.js b/lib/eachOfSeries.js
index d64e7ec..c48a66b 100644
--- a/lib/eachOfSeries.js
+++ b/lib/eachOfSeries.js
@@ -1,5 +1,5 @@
 import eachOfLimit from './eachOfLimit';
-import doLimit from './internal/doLimit';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
@@ -17,5 +17,9 @@ import doLimit from './internal/doLimit';
  * Invoked with (item, key, callback).
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  */
-export default doLimit(eachOfLimit, 1);
+function eachOfSeries(coll, iteratee, callback) {
+    return eachOfLimit(coll, 1, iteratee, callback)
+}
+export default awaitify(eachOfSeries, 3);
diff --git a/lib/eachSeries.js b/lib/eachSeries.js
index ae6f6c7..b4a86ba 100644
--- a/lib/eachSeries.js
+++ b/lib/eachSeries.js
@@ -1,5 +1,5 @@
 import eachLimit from './eachLimit';
-import doLimit from './internal/doLimit';
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.
@@ -19,5 +19,9 @@ import doLimit from './internal/doLimit';
  * Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called when all
  * `iteratee` functions have finished, or an error occurs. Invoked with (err).
+ * @returns {Promise} a promise, if a callback is omitted
  */
-export default doLimit(eachLimit, 1);
+function eachSeries(coll, iteratee, callback) {
+    return eachLimit(coll, 1, iteratee, callback)
+}
+export default awaitify(eachSeries, 3);
diff --git a/lib/every.js b/lib/every.js
index be2bc4a..a5ce971 100644
--- a/lib/every.js
+++ b/lib/every.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallel from './internal/doParallel';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * Returns `true` if every element in `coll` satisfies an async test. If any
@@ -19,6 +20,7 @@ import doParallel from './internal/doParallel';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result will be either `true` or `false`
  * depending on the values of the async tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  * @example
  *
  * async.every(['file1','file2','file3'], function(filePath, callback) {
@@ -29,4 +31,7 @@ import doParallel from './internal/doParallel';
  *     // if result is true then every file exists
  * });
  */
-export default doParallel(createTester(bool => !bool, res => !res));
+function every(coll, iteratee, callback) {
+    return createTester(bool => !bool, res => !res)(eachOf, coll, iteratee, callback)
+}
+export default awaitify(every, 3);
diff --git a/lib/everyLimit.js b/lib/everyLimit.js
index 78ffa36..787c704 100644
--- a/lib/everyLimit.js
+++ b/lib/everyLimit.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallelLimit from './internal/doParallelLimit';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.
@@ -20,5 +21,9 @@ import doParallelLimit from './internal/doParallelLimit';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result will be either `true` or `false`
  * depending on the values of the async tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doParallelLimit(createTester(bool => !bool, res => !res));
+function everyLimit(coll, limit, iteratee, callback) {
+    return createTester(bool => !bool, res => !res)(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(everyLimit, 4);
diff --git a/lib/everySeries.js b/lib/everySeries.js
index c450bff..07d2612 100644
--- a/lib/everySeries.js
+++ b/lib/everySeries.js
@@ -1,5 +1,6 @@
-import everyLimit from './everyLimit';
-import doLimit from './internal/doLimit';
+import createTester from './internal/createTester';
+import eachOfSeries from './eachOfSeries';
+import awaitify from './internal/awaitify';
 
 /**
  * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.
@@ -19,5 +20,9 @@ import doLimit from './internal/doLimit';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result will be either `true` or `false`
  * depending on the values of the async tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doLimit(everyLimit, 1);
+function everySeries(coll, iteratee, callback) {
+    return createTester(bool => !bool, res => !res)(eachOfSeries, coll, iteratee, callback)
+}
+export default awaitify(everySeries, 3);
diff --git a/lib/filter.js b/lib/filter.js
index 692802b..b0f3029 100644
--- a/lib/filter.js
+++ b/lib/filter.js
@@ -1,5 +1,6 @@
-import filter from './internal/filter';
-import doParallel from './internal/doParallel';
+import _filter from './internal/filter';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * Returns a new array of all the values in `coll` which pass an async truth
@@ -18,6 +19,7 @@ import doParallel from './internal/doParallel';
  * with a boolean argument once it has completed. Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback provided
  * @example
  *
  * async.filter(['file1','file2','file3'], function(filePath, callback) {
@@ -28,4 +30,7 @@ import doParallel from './internal/doParallel';
  *     // results now equals an array of the existing files
  * });
  */
-export default doParallel(filter);
+function filter (coll, iteratee, callback) {
+    return _filter(eachOf, coll, iteratee, callback)
+}
+export default awaitify(filter, 3);
diff --git a/lib/filterLimit.js b/lib/filterLimit.js
index 946002d..b421caa 100644
--- a/lib/filterLimit.js
+++ b/lib/filterLimit.js
@@ -1,5 +1,6 @@
-import filter from './internal/filter';
-import doParallelLimit from './internal/doParallelLimit';
+import _filter from './internal/filter';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a
@@ -19,5 +20,9 @@ import doParallelLimit from './internal/doParallelLimit';
  * with a boolean argument once it has completed. Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doParallelLimit(filter);
+function filterLimit (coll, limit, iteratee, callback) {
+    return _filter(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(filterLimit, 4);
diff --git a/lib/filterSeries.js b/lib/filterSeries.js
index 908afbc..f53c3d8 100644
--- a/lib/filterSeries.js
+++ b/lib/filterSeries.js
@@ -1,5 +1,6 @@
-import filterLimit from './filterLimit';
-import doLimit from './internal/doLimit';
+import _filter from './internal/filter';
+import eachOfSeries from './eachOfSeries'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.
@@ -17,5 +18,9 @@ import doLimit from './internal/doLimit';
  * with a boolean argument once it has completed. Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results)
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doLimit(filterLimit, 1);
+function filterSeries (coll, iteratee, callback) {
+    return _filter(eachOfSeries, coll, iteratee, callback)
+}
+export default awaitify(filterSeries, 3);
diff --git a/lib/forever.js b/lib/forever.js
index fb69adf..4914c21 100644
--- a/lib/forever.js
+++ b/lib/forever.js
@@ -1,7 +1,7 @@
-import noop from './internal/noop';
 import onlyOnce from './internal/onlyOnce';
 import ensureAsync from './ensureAsync';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * Calls the asynchronous function `fn` with a callback parameter that allows it
@@ -19,6 +19,8 @@ import wrapAsync from './internal/wrapAsync';
  * Invoked with (next).
  * @param {Function} [errback] - when `fn` passes an error to it's callback,
  * this function will be called, and execution stops. Invoked with (err).
+ * @returns {Promise} a promise that rejects if an error occurs and an errback
+ * is not passed
  * @example
  *
  * async.forever(
@@ -32,8 +34,8 @@ import wrapAsync from './internal/wrapAsync';
  *     }
  * );
  */
-export default function forever(fn, errback) {
-    var done = onlyOnce(errback || noop);
+function forever(fn, errback) {
+    var done = onlyOnce(errback);
     var task = wrapAsync(ensureAsync(fn));
 
     function next(err) {
@@ -41,5 +43,6 @@ export default function forever(fn, errback) {
         if (err === false) return;
         task(next);
     }
-    next();
+    return next();
 }
+export default awaitify(forever, 2)
diff --git a/lib/groupBy.js b/lib/groupBy.js
index 860a01f..2993367 100644
--- a/lib/groupBy.js
+++ b/lib/groupBy.js
@@ -1,4 +1,3 @@
-import doLimit from './internal/doLimit';
 import groupByLimit from './groupByLimit';
 
 /**
@@ -25,6 +24,7 @@ import groupByLimit from './groupByLimit';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Result is an `Object` whoses
  * properties are arrays of values which returned the corresponding key.
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.groupBy(['userId1', 'userId2', 'userId3'], function(userId, callback) {
@@ -37,4 +37,6 @@ import groupByLimit from './groupByLimit';
  *     // e.g. { 30: ['userId1', 'userId3'], 42: ['userId2']};
  * });
  */
-export default doLimit(groupByLimit, Infinity);
+export default function groupBy (coll, iteratee, callback) {
+    return groupByLimit(coll, Infinity, iteratee, callback)
+}
diff --git a/lib/groupByLimit.js b/lib/groupByLimit.js
index f0402aa..24d5c40 100644
--- a/lib/groupByLimit.js
+++ b/lib/groupByLimit.js
@@ -1,6 +1,7 @@
-import noop from './internal/noop';
 import mapLimit from './mapLimit';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
+
 /**
  * The same as [`groupBy`]{@link module:Collections.groupBy} but runs a maximum of `limit` async operations at a time.
  *
@@ -19,11 +20,11 @@ import wrapAsync from './internal/wrapAsync';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Result is an `Object` whoses
  * properties are arrays of values which returned the corresponding key.
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default function(coll, limit, iteratee, callback) {
-    callback = callback || noop;
+function groupByLimit(coll, limit, iteratee, callback) {
     var _iteratee = wrapAsync(iteratee);
-    mapLimit(coll, limit, (val, iterCb) => {
+    return mapLimit(coll, limit, (val, iterCb) => {
         _iteratee(val, (err, key) => {
             if (err) return iterCb(err);
             return iterCb(null, {key, val});
@@ -49,3 +50,5 @@ export default function(coll, limit, iteratee, callback) {
         return callback(err, result);
     });
 }
+
+export default awaitify(groupByLimit, 4);
diff --git a/lib/groupBySeries.js b/lib/groupBySeries.js
index a093d7f..ee673e1 100644
--- a/lib/groupBySeries.js
+++ b/lib/groupBySeries.js
@@ -1,4 +1,3 @@
-import doLimit from './internal/doLimit';
 import groupByLimit from './groupByLimit';
 
 /**
@@ -11,7 +10,6 @@ import groupByLimit from './groupByLimit';
  * @see [async.groupBy]{@link module:Collections.groupBy}
  * @category Collection
  * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
  * @param {AsyncFunction} iteratee - An async function to apply to each item in
  * `coll`.
  * The iteratee should complete with a `key` to group the value under.
@@ -19,5 +17,8 @@ import groupByLimit from './groupByLimit';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Result is an `Object` whoses
  * properties are arrays of values which returned the corresponding key.
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doLimit(groupByLimit, 1);
+export default function groupBySeries (coll, iteratee, callback) {
+    return groupByLimit(coll, 1, iteratee, callback)
+}
diff --git a/lib/internal/awaitify.js b/lib/internal/awaitify.js
new file mode 100644
index 0000000..57628de
--- /dev/null
+++ b/lib/internal/awaitify.js
@@ -0,0 +1,24 @@
+// conditionally promisify a function.
+// only return a promise if a callback is omitted
+export default function awaitify (asyncFn, arity = asyncFn.length) {
+    if (!arity) throw new Error('arity is undefined')
+    function awaitable (...args) {
+        if (typeof args[arity - 1] === 'function') {
+            return asyncFn.apply(this, args)
+        }
+
+        return new Promise((resolve, reject) => {
+            args[arity - 1] = (err, ...cbArgs) => {
+                if (err) return reject(err)
+                resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0])
+            }
+            asyncFn.apply(this, args)
+        })
+    }
+
+    Object.defineProperty(awaitable, 'name', {
+        value: `awaitable(${asyncFn.name})`
+    })
+
+    return awaitable
+}
diff --git a/lib/internal/createTester.js b/lib/internal/createTester.js
index 4a5d39f..5858702 100644
--- a/lib/internal/createTester.js
+++ b/lib/internal/createTester.js
@@ -1,11 +1,11 @@
-import noop from './noop';
 import breakLoop from './breakLoop';
+import wrapAsync from './wrapAsync'
 
 export default function _createTester(check, getResult) {
-    return (eachfn, arr, iteratee, cb) => {
-        cb = cb || noop;
+    return (eachfn, arr, _iteratee, cb) => {
         var testPassed = false;
         var testResult;
+        const iteratee = wrapAsync(_iteratee)
         eachfn(arr, (value, _, callback) => {
             iteratee(value, (err, result) => {
                 if (err) return callback(err)
diff --git a/lib/internal/doLimit.js b/lib/internal/doLimit.js
deleted file mode 100644
index 70fb495..0000000
--- a/lib/internal/doLimit.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export default function doLimit(fn, limit) {
-    return (iterable, iteratee, cb) => fn(iterable, limit, iteratee, cb)
-}
diff --git a/lib/internal/doParallel.js b/lib/internal/doParallel.js
deleted file mode 100644
index 2b76b68..0000000
--- a/lib/internal/doParallel.js
+++ /dev/null
@@ -1,6 +0,0 @@
-import eachOf from '../eachOf';
-import wrapAsync from './wrapAsync';
-
-export default function doParallel(fn) {
-    return (obj, iteratee, cb) => fn(eachOf, obj, wrapAsync(iteratee), cb);
-}
diff --git a/lib/internal/doParallelLimit.js b/lib/internal/doParallelLimit.js
deleted file mode 100644
index 5e2703a..0000000
--- a/lib/internal/doParallelLimit.js
+++ /dev/null
@@ -1,6 +0,0 @@
-import eachOfLimit from './eachOfLimit';
-import wrapAsync from './wrapAsync';
-
-export default function doParallelLimit(fn) {
-    return (obj, limit, iteratee, cb) => fn(eachOfLimit(limit), obj, wrapAsync(iteratee), cb);
-}
diff --git a/lib/internal/eachOfLimit.js b/lib/internal/eachOfLimit.js
index 999cbfa..ec6c8be 100644
--- a/lib/internal/eachOfLimit.js
+++ b/lib/internal/eachOfLimit.js
@@ -1,4 +1,3 @@
-import noop from './noop';
 import once from './once';
 
 import iterator from './iterator';
@@ -10,7 +9,7 @@ import breakLoop from './breakLoop';
 
 export default (limit) => {
     return (obj, iteratee, callback) => {
-        callback = once(callback || noop);
+        callback = once(callback);
         if (limit <= 0) {
             throw new RangeError('concurrency limit cannot be less than 1')
         }
diff --git a/lib/internal/filter.js b/lib/internal/filter.js
index ab37390..15d7ae3 100644
--- a/lib/internal/filter.js
+++ b/lib/internal/filter.js
@@ -1,5 +1,4 @@
 import isArrayLike from './isArrayLike';
-import noop from './noop';
 
 import wrapAsync from './wrapAsync';
 
@@ -40,5 +39,5 @@ function filterGeneric(eachfn, coll, iteratee, callback) {
 
 export default function _filter(eachfn, coll, iteratee, callback) {
     var filter = isArrayLike(coll) ? filterArray : filterGeneric;
-    return filter(eachfn, coll, wrapAsync(iteratee), callback || noop);
+    return filter(eachfn, coll, wrapAsync(iteratee), callback);
 }
diff --git a/lib/internal/initialParams.js b/lib/internal/initialParams.js
index 4014785..9ea253a 100644
--- a/lib/internal/initialParams.js
+++ b/lib/internal/initialParams.js
@@ -1,6 +1,6 @@
 export default function (fn) {
     return function (...args/*, callback*/) {
         var callback = args.pop();
-        fn.call(this, args, callback);
+        return fn.call(this, args, callback);
     };
 }
diff --git a/lib/internal/map.js b/lib/internal/map.js
index 3da8d9c..092f76d 100644
--- a/lib/internal/map.js
+++ b/lib/internal/map.js
@@ -1,8 +1,6 @@
-import noop from './noop';
 import wrapAsync from './wrapAsync';
 
 export default function _asyncMap(eachfn, arr, iteratee, callback) {
-    callback = callback || noop;
     arr = arr || [];
     var results = [];
     var counter = 0;
diff --git a/lib/internal/noop.js b/lib/internal/noop.js
deleted file mode 100644
index ca6a744..0000000
--- a/lib/internal/noop.js
+++ /dev/null
@@ -1 +0,0 @@
-export default function noop() {}
diff --git a/lib/internal/once.js b/lib/internal/once.js
index 1293d5e..10ab26b 100644
--- a/lib/internal/once.js
+++ b/lib/internal/once.js
@@ -1,8 +1,10 @@
 export default function once(fn) {
-    return function (...args) {
+    function wrapper (...args) {
         if (fn === null) return;
         var callFn = fn;
         fn = null;
         callFn.apply(this, args);
-    };
+    }
+    Object.assign(wrapper, fn)
+    return wrapper
 }
diff --git a/lib/internal/parallel.js b/lib/internal/parallel.js
index 8abf0d1..790b6e8 100644
--- a/lib/internal/parallel.js
+++ b/lib/internal/parallel.js
@@ -1,9 +1,8 @@
 import isArrayLike from './isArrayLike';
-import noop from './noop';
 import wrapAsync from './wrapAsync';
+import awaitify from './awaitify'
 
-export default function _parallel(eachfn, tasks, callback) {
-    callback = callback || noop;
+export default awaitify((eachfn, tasks, callback) => {
     var results = isArrayLike(tasks) ? [] : {};
 
     eachfn(tasks, (task, key, taskCb) => {
@@ -15,4 +14,4 @@ export default function _parallel(eachfn, tasks, callback) {
             taskCb(err);
         });
     }, err => callback(err, results));
-}
+}, 3)
diff --git a/lib/internal/promiseCallback.js b/lib/internal/promiseCallback.js
new file mode 100644
index 0000000..685dd7a
--- /dev/null
+++ b/lib/internal/promiseCallback.js
@@ -0,0 +1,19 @@
+const PROMISE_SYMBOL = Symbol('promiseCallback')
+
+function promiseCallback () {
+    let resolve, reject
+    function callback (err, ...args) {
+        if (err) return reject(err)
+        resolve(args.length > 1 ? args : args[0])
+    }
+
+    callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
+        resolve = res,
+        reject = rej
+    })
+
+    return callback
+}
+
+
+export { promiseCallback, PROMISE_SYMBOL }
diff --git a/lib/internal/queue.js b/lib/internal/queue.js
index 4c1f5cc..751b562 100644
--- a/lib/internal/queue.js
+++ b/lib/internal/queue.js
@@ -1,9 +1,10 @@
-import noop from './noop';
 import onlyOnce from './onlyOnce';
 import setImmediate from './setImmediate';
 import DLL from './DoublyLinkedList';
 import wrapAsync from './wrapAsync';
 
+const noop = () => {}
+
 export default function queue(worker, concurrency, payload) {
     if (concurrency == null) {
         concurrency = 1;
diff --git a/lib/internal/reject.js b/lib/internal/reject.js
index 1522632..d0549cc 100644
--- a/lib/internal/reject.js
+++ b/lib/internal/reject.js
@@ -1,6 +1,8 @@
 import filter from './filter';
+import wrapAsync from './wrapAsync'
 
-export default function reject(eachfn, arr, iteratee, callback) {
+export default function reject(eachfn, arr, _iteratee, callback) {
+    const iteratee = wrapAsync(_iteratee)
     return filter(eachfn, arr, (value, cb) => {
         iteratee(value, (err, v) => {
             cb(err, !v);
diff --git a/lib/internal/wrapAsync.js b/lib/internal/wrapAsync.js
index 5c3edd9..270cf8f 100644
--- a/lib/internal/wrapAsync.js
+++ b/lib/internal/wrapAsync.js
@@ -13,6 +13,7 @@ function isAsyncIterable(obj) {
 }
 
 function wrapAsync(asyncFn) {
+    if (typeof asyncFn !== 'function') throw new Error('expected a function')
     return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
 }
 
diff --git a/lib/map.js b/lib/map.js
index 2512c32..c32bd2d 100644
--- a/lib/map.js
+++ b/lib/map.js
@@ -1,5 +1,6 @@
-import doParallel from './internal/doParallel';
-import map from './internal/map';
+import _map from './internal/map';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * Produces a new collection of values by mapping each value in `coll` through
@@ -31,10 +32,14 @@ import map from './internal/map';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Results is an Array of the
  * transformed items from the `coll`. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.map(['file1','file2','file3'], fs.stat, function(err, results) {
  *     // results is now an array of stats for each file
  * });
  */
-export default doParallel(map);
+function map (coll, iteratee, callback) {
+    return _map(eachOf, coll, iteratee, callback)
+}
+export default awaitify(map, 3);
diff --git a/lib/mapLimit.js b/lib/mapLimit.js
index 905edc6..63fade2 100644
--- a/lib/mapLimit.js
+++ b/lib/mapLimit.js
@@ -1,5 +1,6 @@
-import doParallelLimit from './internal/doParallelLimit';
-import map from './internal/map';
+import _map from './internal/map';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.
@@ -19,5 +20,9 @@ import map from './internal/map';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Results is an array of the
  * transformed items from the `coll`. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doParallelLimit(map);
+function mapLimit (coll, limit, iteratee, callback) {
+    return _map(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(mapLimit, 4);
diff --git a/lib/mapSeries.js b/lib/mapSeries.js
index 96b5f0a..55c6831 100644
--- a/lib/mapSeries.js
+++ b/lib/mapSeries.js
@@ -1,5 +1,6 @@
-import mapLimit from './mapLimit';
-import doLimit from './internal/doLimit';
+import _map from './internal/map';
+import eachOfSeries from './eachOfSeries'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.
@@ -18,5 +19,9 @@ import doLimit from './internal/doLimit';
  * @param {Function} [callback] - A callback which is called when all `iteratee`
  * functions have finished, or an error occurs. Results is an array of the
  * transformed items from the `coll`. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doLimit(mapLimit, 1);
+function mapSeries (coll, iteratee, callback) {
+    return _map(eachOfSeries, coll, iteratee, callback)
+}
+export default awaitify(mapSeries, 3);
diff --git a/lib/mapValues.js b/lib/mapValues.js
index d6a4ad2..79edfd4 100644
--- a/lib/mapValues.js
+++ b/lib/mapValues.js
@@ -1,6 +1,4 @@
 import mapValuesLimit from './mapValuesLimit';
-import doLimit from './internal/doLimit';
-
 
 /**
  * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.
@@ -29,6 +27,7 @@ import doLimit from './internal/doLimit';
  * functions have finished, or an error occurs. `result` is a new object consisting
  * of each key from `obj`, with each transformed value on the right-hand side.
  * Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.mapValues({
@@ -46,5 +45,6 @@ import doLimit from './internal/doLimit';
  *     // }
  * });
  */
-
-export default doLimit(mapValuesLimit, Infinity);
+export default function mapValues(obj, iteratee, callback) {
+    return mapValuesLimit(obj, Infinity, iteratee, callback)
+}
diff --git a/lib/mapValuesLimit.js b/lib/mapValuesLimit.js
index 2267aaf..af56f25 100644
--- a/lib/mapValuesLimit.js
+++ b/lib/mapValuesLimit.js
@@ -1,6 +1,5 @@
-import eachOfLimit from './eachOfLimit';
-
-import noop from './internal/noop';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 import once from './internal/once';
 import wrapAsync from './internal/wrapAsync';
 
@@ -24,12 +23,13 @@ import wrapAsync from './internal/wrapAsync';
  * functions have finished, or an error occurs. `result` is a new object consisting
  * of each key from `obj`, with each transformed value on the right-hand side.
  * Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default function mapValuesLimit(obj, limit, iteratee, callback) {
-    callback = once(callback || noop);
+function mapValuesLimit(obj, limit, iteratee, callback) {
+    callback = once(callback);
     var newObj = {};
     var _iteratee = wrapAsync(iteratee)
-    eachOfLimit(obj, limit, (val, key, next) => {
+    return eachOfLimit(limit)(obj, (val, key, next) => {
         _iteratee(val, key, (err, result) => {
             if (err) return next(err);
             newObj[key] = result;
@@ -37,3 +37,5 @@ export default function mapValuesLimit(obj, limit, iteratee, callback) {
         });
     }, err => callback(err, newObj));
 }
+
+export default awaitify(mapValuesLimit, 4)
diff --git a/lib/mapValuesSeries.js b/lib/mapValuesSeries.js
index ab0b8f8..59e4b1a 100644
--- a/lib/mapValuesSeries.js
+++ b/lib/mapValuesSeries.js
@@ -1,5 +1,4 @@
 import mapValuesLimit from './mapValuesLimit';
-import doLimit from './internal/doLimit';
 
 /**
  * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.
@@ -19,5 +18,8 @@ import doLimit from './internal/doLimit';
  * functions have finished, or an error occurs. `result` is a new object consisting
  * of each key from `obj`, with each transformed value on the right-hand side.
  * Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doLimit(mapValuesLimit, 1);
+export default function mapValuesSeries(obj, iteratee, callback) {
+    return mapValuesLimit(obj, 1, iteratee, callback)
+}
diff --git a/lib/parallel.js b/lib/parallel.js
index edf8be4..fafae9d 100644
--- a/lib/parallel.js
+++ b/lib/parallel.js
@@ -1,5 +1,5 @@
 import eachOf from './eachOf';
-import parallel from './internal/parallel';
+import _parallel from './internal/parallel';
 
 /**
  * Run the `tasks` collection of functions in parallel, without waiting until
@@ -34,6 +34,7 @@ import parallel from './internal/parallel';
  * functions have completed successfully. This function gets a results array
  * (or object) containing all the result arguments passed to the task callbacks.
  * Invoked with (err, results).
+ * @returns {Promise} a promise, if a callback is not passed
  *
  * @example
  * async.parallel([
@@ -70,6 +71,6 @@ import parallel from './internal/parallel';
  *     // results is now equals to: {one: 1, two: 2}
  * });
  */
-export default function parallelLimit(tasks, callback) {
-    parallel(eachOf, tasks, callback);
+export default function parallel(tasks, callback) {
+    return _parallel(eachOf, tasks, callback);
 }
diff --git a/lib/parallelLimit.js b/lib/parallelLimit.js
index 9a857b8..ee4335c 100644
--- a/lib/parallelLimit.js
+++ b/lib/parallelLimit.js
@@ -19,7 +19,8 @@ import parallel from './internal/parallel';
  * functions have completed successfully. This function gets a results array
  * (or object) containing all the result arguments passed to the task callbacks.
  * Invoked with (err, results).
+ * @returns {Promise} a promise, if a callback is not passed
  */
 export default function parallelLimit(tasks, limit, callback) {
-    parallel(eachOfLimit(limit), tasks, callback);
+    return parallel(eachOfLimit(limit), tasks, callback);
 }
diff --git a/lib/priorityQueue.js b/lib/priorityQueue.js
index aa9b578..4eaea38 100644
--- a/lib/priorityQueue.js
+++ b/lib/priorityQueue.js
@@ -1,7 +1,4 @@
-import noop from './internal/noop';
-
 import setImmediate from './setImmediate';
-
 import queue from './queue';
 
 /**
@@ -32,8 +29,7 @@ export default function(worker, concurrency) {
     var q = queue(worker, concurrency);
 
     // Override push to accept second parameter representing priority
-    q.push = function(data, priority, callback) {
-        if (callback == null) callback = noop;
+    q.push = function(data, priority = 0, callback = () => {}) {
         if (typeof callback !== 'function') {
             throw new Error('task callback must be a function');
         }
@@ -46,7 +42,6 @@ export default function(worker, concurrency) {
             return setImmediate(() => q.drain());
         }
 
-        priority = priority || 0;
         var nextNode = q._tasks.head;
         while (nextNode && priority >= nextNode.priority) {
             nextNode = nextNode.next;
diff --git a/lib/race.js b/lib/race.js
index 0593a72..05101a3 100644
--- a/lib/race.js
+++ b/lib/race.js
@@ -1,6 +1,6 @@
-import noop from './internal/noop';
 import once from './internal/once';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify';
 
 /**
  * Runs the `tasks` array of functions in parallel, without waiting until the
@@ -38,11 +38,13 @@ import wrapAsync from './internal/wrapAsync';
  *     // the result will be equal to 'two' as it finishes earlier
  * });
  */
-export default function race(tasks, callback) {
-    callback = once(callback || noop);
+function race(tasks, callback) {
+    callback = once(callback);
     if (!Array.isArray(tasks)) return callback(new TypeError('First argument to race must be an array of functions'));
     if (!tasks.length) return callback();
     for (var i = 0, l = tasks.length; i < l; i++) {
         wrapAsync(tasks[i])(callback);
     }
 }
+
+export default awaitify(race, 2)
diff --git a/lib/reduce.js b/lib/reduce.js
index 1a6c036..571bc5a 100644
--- a/lib/reduce.js
+++ b/lib/reduce.js
@@ -1,7 +1,7 @@
 import eachOfSeries from './eachOfSeries';
-import noop from './internal/noop';
 import once from './internal/once';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * Reduces `coll` into a single value using an async `iteratee` to return each
@@ -32,6 +32,7 @@ import wrapAsync from './internal/wrapAsync';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result is the reduced value. Invoked with
  * (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.reduce([1,2,3], 0, function(memo, item, callback) {
@@ -43,13 +44,15 @@ import wrapAsync from './internal/wrapAsync';
  *     // result is now equal to the last value of memo, which is 6
  * });
  */
-export default function reduce(coll, memo, iteratee, callback) {
-    callback = once(callback || noop);
+function reduce(coll, memo, iteratee, callback) {
+    callback = once(callback);
     var _iteratee = wrapAsync(iteratee);
-    eachOfSeries(coll, (x, i, iterCb) => {
+    return eachOfSeries(coll, (x, i, iterCb) => {
         _iteratee(memo, x, (err, v) => {
             memo = v;
             iterCb(err);
         });
     }, err => callback(err, memo));
 }
+export default awaitify(reduce, 4)
+
diff --git a/lib/reduceRight.js b/lib/reduceRight.js
index dd56a88..994eaf9 100644
--- a/lib/reduceRight.js
+++ b/lib/reduceRight.js
@@ -21,8 +21,9 @@ import reduce from './reduce';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result is the reduced value. Invoked with
  * (err, result).
+ * @returns {Promise} a promise, if no callback is passed
  */
 export default function reduceRight (array, memo, iteratee, callback) {
     var reversed = [...array].reverse();
-    reduce(reversed, memo, iteratee, callback);
+    return reduce(reversed, memo, iteratee, callback);
 }
diff --git a/lib/reject.js b/lib/reject.js
index cfac12d..c1de825 100644
--- a/lib/reject.js
+++ b/lib/reject.js
@@ -1,5 +1,6 @@
-import reject from './internal/reject';
-import doParallel from './internal/doParallel';
+import _reject from './internal/reject';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * The opposite of [`filter`]{@link module:Collections.filter}. Removes values that pass an `async` truth test.
@@ -17,6 +18,7 @@ import doParallel from './internal/doParallel';
  * Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * async.reject(['file1','file2','file3'], function(filePath, callback) {
@@ -28,4 +30,7 @@ import doParallel from './internal/doParallel';
  *     createFiles(results);
  * });
  */
-export default doParallel(reject);
+function reject (coll, iteratee, callback) {
+    return _reject(eachOf, coll, iteratee, callback)
+}
+export default awaitify(reject, 3);
diff --git a/lib/rejectLimit.js b/lib/rejectLimit.js
index 76e6ffc..d58b291 100644
--- a/lib/rejectLimit.js
+++ b/lib/rejectLimit.js
@@ -1,6 +1,6 @@
-import reject from './internal/reject';
-import doParallelLimit from './internal/doParallelLimit';
-
+import _reject from './internal/reject';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 /**
  * The same as [`reject`]{@link module:Collections.reject} but runs a maximum of `limit` async operations at a
  * time.
@@ -19,5 +19,9 @@ import doParallelLimit from './internal/doParallelLimit';
  * Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doParallelLimit(reject);
+function rejectLimit (coll, limit, iteratee, callback) {
+    return _reject(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(rejectLimit, 4);
diff --git a/lib/rejectSeries.js b/lib/rejectSeries.js
index 3f2d62f..56b08a3 100644
--- a/lib/rejectSeries.js
+++ b/lib/rejectSeries.js
@@ -1,5 +1,6 @@
-import rejectLimit from './rejectLimit';
-import doLimit from './internal/doLimit';
+import _reject from './internal/reject';
+import eachOfSeries from './eachOfSeries'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`reject`]{@link module:Collections.reject} but runs only a single async operation at a time.
@@ -17,5 +18,9 @@ import doLimit from './internal/doLimit';
  * Invoked with (item, callback).
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  */
-export default doLimit(rejectLimit, 1);
+function rejectSeries (coll, iteratee, callback) {
+    return _reject(eachOfSeries, coll, iteratee, callback)
+}
+export default awaitify(rejectSeries, 3);
diff --git a/lib/retry.js b/lib/retry.js
index 2a353dc..5ef6971 100644
--- a/lib/retry.js
+++ b/lib/retry.js
@@ -1,5 +1,5 @@
-import noop from './internal/noop';
 import wrapAsync from './internal/wrapAsync';
+import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback';
 
 function constant(value) {
     return function () {
@@ -39,6 +39,7 @@ function constant(value) {
  * task has succeeded, or after the final failed attempt. It receives the `err`
  * and `result` arguments of the last attempt at completing the `task`. Invoked
  * with (err, results).
+ * @returns {Promise} a promise if no callback provided
  *
  * @example
  *
@@ -101,11 +102,11 @@ export default function retry(opts, task, callback) {
     };
 
     if (arguments.length < 3 && typeof opts === 'function') {
-        callback = task || noop;
+        callback = task || promiseCallback();
         task = opts;
     } else {
         parseTimes(options, opts);
-        callback = callback || noop;
+        callback = callback || promiseCallback();
     }
 
     if (typeof task !== 'function') {
@@ -129,6 +130,7 @@ export default function retry(opts, task, callback) {
     }
 
     retryAttempt();
+    return callback[PROMISE_SYMBOL]
 }
 
 function parseTimes(acc, t) {
diff --git a/lib/retryable.js b/lib/retryable.js
index 9422eed..ad99801 100644
--- a/lib/retryable.js
+++ b/lib/retryable.js
@@ -1,6 +1,7 @@
 import retry from './retry';
 import initialParams from './internal/initialParams';
-import wrapAsync from './internal/wrapAsync';
+import {default as wrapAsync, isAsync} from './internal/wrapAsync';
+import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback';
 
 /**
  * A close relative of [`retry`]{@link module:ControlFlow.retry}.  This method
@@ -14,7 +15,8 @@ import wrapAsync from './internal/wrapAsync';
  * @see [async.retry]{@link module:ControlFlow.retry}
  * @category Control Flow
  * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - optional
- * options, exactly the same as from `retry`
+ * options, exactly the same as from `retry`, except for a `opts.arity` that
+ * is the arity of the `task` function, defaulting to `task.length`
  * @param {AsyncFunction} task - the asynchronous function to wrap.
  * This function will be passed any arguments passed to the returned wrapper.
  * Invoked with (...args, callback).
@@ -30,13 +32,21 @@ import wrapAsync from './internal/wrapAsync';
  *     })]
  * }, callback);
  */
-export default function (opts, task) {
+export default function retryable (opts, task) {
     if (!task) {
         task = opts;
         opts = null;
     }
+    let arity = (opts && opts.arity) || task.length
+    if (isAsync(task)) {
+        arity += 1
+    }
     var _task = wrapAsync(task);
     return initialParams((args, callback) => {
+        if (args.length < arity - 1 || callback == null) {
+            args.push(callback)
+            callback = promiseCallback()
+        }
         function taskFn(cb) {
             _task(...args, cb);
         }
@@ -44,5 +54,6 @@ export default function (opts, task) {
         if (opts) retry(opts, taskFn, callback);
         else retry(taskFn, callback);
 
+        return callback[PROMISE_SYMBOL]
     });
 }
diff --git a/lib/seq.js b/lib/seq.js
index 1363cbd..6c9ede7 100644
--- a/lib/seq.js
+++ b/lib/seq.js
@@ -1,6 +1,6 @@
-import noop from './internal/noop';
 import reduce from './reduce';
 import wrapAsync from './internal/wrapAsync';
+import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback';
 
 /**
  * Version of the compose function that is more natural to read. Each function
@@ -49,7 +49,7 @@ export default function seq(...functions) {
         if (typeof cb == 'function') {
             args.pop();
         } else {
-            cb = noop;
+            cb = promiseCallback();
         }
 
         reduce(_functions, args, (newargs, fn, iterCb) => {
@@ -58,5 +58,7 @@ export default function seq(...functions) {
             }));
         },
         (err, results) => cb(err, ...results));
+
+        return cb[PROMISE_SYMBOL]
     };
 }
diff --git a/lib/series.js b/lib/series.js
index 539a1e7..71367a9 100644
--- a/lib/series.js
+++ b/lib/series.js
@@ -1,4 +1,4 @@
-import parallel from './internal/parallel';
+import _parallel from './internal/parallel';
 import eachOfSeries from './eachOfSeries';
 
 /**
@@ -34,6 +34,7 @@ import eachOfSeries from './eachOfSeries';
  * functions have completed. This function gets a results array (or object)
  * containing all the result arguments passed to the `task` callbacks. Invoked
  * with (err, result).
+ * @return {Promise} a promise, if no callback is passed
  * @example
  * async.series([
  *     function(callback) {
@@ -66,5 +67,5 @@ import eachOfSeries from './eachOfSeries';
  * });
  */
 export default function series(tasks, callback) {
-    parallel(eachOfSeries, tasks, callback);
+    return _parallel(eachOfSeries, tasks, callback);
 }
diff --git a/lib/some.js b/lib/some.js
index 65543bb..378ccdf 100644
--- a/lib/some.js
+++ b/lib/some.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallel from './internal/doParallel';
+import eachOf from './eachOf'
+import awaitify from './internal/awaitify'
 
 /**
  * Returns `true` if at least one element in the `coll` satisfies an async test.
@@ -21,6 +22,7 @@ import doParallel from './internal/doParallel';
  * iteratee returns `true`, or after all the iteratee functions have finished.
  * Result will be either `true` or `false` depending on the values of the async
  * tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  * @example
  *
  * async.some(['file1','file2','file3'], function(filePath, callback) {
@@ -31,4 +33,7 @@ import doParallel from './internal/doParallel';
  *     // if result is true then at least one of the files exists
  * });
  */
-export default doParallel(createTester(Boolean, res => res));
+function some(coll, iteratee, callback) {
+    return createTester(Boolean, res => res)(eachOf, coll, iteratee, callback)
+}
+export default awaitify(some, 3);
diff --git a/lib/someLimit.js b/lib/someLimit.js
index fb6841c..2defb28 100644
--- a/lib/someLimit.js
+++ b/lib/someLimit.js
@@ -1,5 +1,6 @@
 import createTester from './internal/createTester';
-import doParallelLimit from './internal/doParallelLimit';
+import eachOfLimit from './internal/eachOfLimit'
+import awaitify from './internal/awaitify'
 
 /**
  * The same as [`some`]{@link module:Collections.some} but runs a maximum of `limit` async operations at a time.
@@ -21,5 +22,9 @@ import doParallelLimit from './internal/doParallelLimit';
  * iteratee returns `true`, or after all the iteratee functions have finished.
  * Result will be either `true` or `false` depending on the values of the async
  * tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doParallelLimit(createTester(Boolean, res => res));
+function someLimit(coll, limit, iteratee, callback) {
+    return createTester(Boolean, res => res)(eachOfLimit(limit), coll, iteratee, callback)
+}
+export default awaitify(someLimit, 4);
diff --git a/lib/someSeries.js b/lib/someSeries.js
index c05ca1f..7842124 100644
--- a/lib/someSeries.js
+++ b/lib/someSeries.js
@@ -1,5 +1,6 @@
-import someLimit from './someLimit';
-import doLimit from './internal/doLimit';
+import createTester from './internal/createTester';
+import eachOfSeries from './eachOfSeries';
+import awaitify from './internal/awaitify';
 
 /**
  * The same as [`some`]{@link module:Collections.some} but runs only a single async operation at a time.
@@ -20,5 +21,9 @@ import doLimit from './internal/doLimit';
  * iteratee returns `true`, or after all the iteratee functions have finished.
  * Result will be either `true` or `false` depending on the values of the async
  * tests. Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  */
-export default doLimit(someLimit, 1);
+function someSeries(coll, iteratee, callback) {
+    return createTester(Boolean, res => res)(eachOfSeries, coll, iteratee, callback)
+}
+export default awaitify(someSeries, 3);
diff --git a/lib/sortBy.js b/lib/sortBy.js
index ba2a804..ec724b6 100644
--- a/lib/sortBy.js
+++ b/lib/sortBy.js
@@ -1,5 +1,6 @@
 import map from './map';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * Sorts a list by the results of running each `coll` value through an async
@@ -20,6 +21,7 @@ import wrapAsync from './internal/wrapAsync';
  * `iteratee` functions have finished, or an error occurs. Results is the items
  * from the original `coll` sorted by the values returned by the `iteratee`
  * calls. Invoked with (err, results).
+ * @returns {Promise} a promise, if no callback passed
  * @example
  *
  * async.sortBy(['file1','file2','file3'], function(file, callback) {
@@ -48,9 +50,9 @@ import wrapAsync from './internal/wrapAsync';
  *     // result callback
  * });
  */
-export default function sortBy (coll, iteratee, callback) {
+function sortBy (coll, iteratee, callback) {
     var _iteratee = wrapAsync(iteratee);
-    map(coll, (x, iterCb) => {
+    return map(coll, (x, iterCb) => {
         _iteratee(x, (err, criteria) => {
             if (err) return iterCb(err);
             iterCb(null, {value: x, criteria});
@@ -65,3 +67,4 @@ export default function sortBy (coll, iteratee, callback) {
         return a < b ? -1 : a > b ? 1 : 0;
     }
 }
+export default awaitify(sortBy, 3)
diff --git a/lib/times.js b/lib/times.js
index ebd336c..15e798f 100644
--- a/lib/times.js
+++ b/lib/times.js
@@ -1,5 +1,4 @@
 import timesLimit from './timesLimit';
-import doLimit from './internal/doLimit';
 
 /**
  * Calls the `iteratee` function `n` times, and accumulates results in the same
@@ -15,6 +14,7 @@ import doLimit from './internal/doLimit';
  * @param {AsyncFunction} iteratee - The async function to call `n` times.
  * Invoked with the iteration index and a callback: (n, next).
  * @param {Function} callback - see {@link module:Collections.map}.
+ * @returns {Promise} a promise, if no callback is provided
  * @example
  *
  * // Pretend this is some complicated async factory
@@ -33,4 +33,6 @@ import doLimit from './internal/doLimit';
  *     // we should now have 5 users
  * });
  */
-export default doLimit(timesLimit, Infinity);
+export default function times (n, iteratee, callback) {
+    return timesLimit(n, Infinity, iteratee, callback)
+}
diff --git a/lib/timesLimit.js b/lib/timesLimit.js
index bb4a1fe..8880ccf 100644
--- a/lib/timesLimit.js
+++ b/lib/timesLimit.js
@@ -17,8 +17,9 @@ import wrapAsync from './internal/wrapAsync';
  * @param {AsyncFunction} iteratee - The async function to call `n` times.
  * Invoked with the iteration index and a callback: (n, next).
  * @param {Function} callback - see [async.map]{@link module:Collections.map}.
+ * @returns {Promise} a promise, if no callback is provided
  */
-export default function timeLimit(count, limit, iteratee, callback) {
+export default function timesLimit(count, limit, iteratee, callback) {
     var _iteratee = wrapAsync(iteratee);
-    mapLimit(range(count), limit, _iteratee, callback);
+    return mapLimit(range(count), limit, _iteratee, callback);
 }
diff --git a/lib/timesSeries.js b/lib/timesSeries.js
index 17ec0ca..b56f6ec 100644
--- a/lib/timesSeries.js
+++ b/lib/timesSeries.js
@@ -1,5 +1,4 @@
 import timesLimit from './timesLimit';
-import doLimit from './internal/doLimit';
 
 /**
  * The same as [times]{@link module:ControlFlow.times} but runs only a single async operation at a time.
@@ -14,5 +13,8 @@ import doLimit from './internal/doLimit';
  * @param {AsyncFunction} iteratee - The async function to call `n` times.
  * Invoked with the iteration index and a callback: (n, next).
  * @param {Function} callback - see {@link module:Collections.map}.
+ * @returns {Promise} a promise, if no callback is provided
  */
-export default doLimit(timesLimit, 1);
+export default function timesSeries (n, iteratee, callback) {
+    return timesLimit(n, 1, iteratee, callback)
+}
diff --git a/lib/transform.js b/lib/transform.js
index 821a0fa..786f5d3 100644
--- a/lib/transform.js
+++ b/lib/transform.js
@@ -1,7 +1,7 @@
 import eachOf from './eachOf';
-import noop from './internal/noop';
 import once from './internal/once';
 import wrapAsync from './internal/wrapAsync';
+import { promiseCallback, PROMISE_SYMBOL } from './internal/promiseCallback';
 
 /**
  * A relative of `reduce`.  Takes an Object or Array, and iterates over each
@@ -22,6 +22,7 @@ import wrapAsync from './internal/wrapAsync';
  * @param {Function} [callback] - A callback which is called after all the
  * `iteratee` functions have finished. Result is the transformed accumulator.
  * Invoked with (err, result).
+ * @returns {Promise} a promise, if no callback provided
  * @example
  *
  * async.transform([1,2,3], function(acc, item, index, callback) {
@@ -46,15 +47,16 @@ import wrapAsync from './internal/wrapAsync';
  * })
  */
 export default function transform (coll, accumulator, iteratee, callback) {
-    if (arguments.length <= 3) {
+    if (arguments.length <= 3 && typeof accumulator === 'function') {
         callback = iteratee;
         iteratee = accumulator;
         accumulator = Array.isArray(coll) ? [] : {};
     }
-    callback = once(callback || noop);
+    callback = once(callback || promiseCallback());
     var _iteratee = wrapAsync(iteratee);
 
     eachOf(coll, (v, k, cb) => {
         _iteratee(accumulator, v, k, cb);
     }, err => callback(err, accumulator));
+    return callback[PROMISE_SYMBOL]
 }
diff --git a/lib/tryEach.js b/lib/tryEach.js
index af885dc..6677c9d 100644
--- a/lib/tryEach.js
+++ b/lib/tryEach.js
@@ -1,6 +1,6 @@
 import eachSeries from './eachSeries';
-import noop from './internal/noop';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * It runs each task in series but stops whenever any of the functions were
@@ -21,6 +21,7 @@ import wrapAsync from './internal/wrapAsync';
  * of the tasks has succeeded, or all have failed. It receives the `err` and
  * `result` arguments of the last attempt at completing the `task`. Invoked with
  * (err, results).
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  * async.tryEach([
  *     function getDataFromFirstWebsite(callback) {
@@ -39,11 +40,10 @@ import wrapAsync from './internal/wrapAsync';
  * });
  *
  */
-export default function tryEach(tasks, callback) {
+function tryEach(tasks, callback) {
     var error = null;
     var result;
-    callback = callback || noop;
-    eachSeries(tasks, (task, taskCb) => {
+    return eachSeries(tasks, (task, taskCb) => {
         wrapAsync(task)((err, ...args) => {
             if (args.length < 2) {
                 [result] = args;
@@ -55,3 +55,5 @@ export default function tryEach(tasks, callback) {
         });
     }, () => callback(error, result));
 }
+
+export default awaitify(tryEach)
diff --git a/lib/until.js b/lib/until.js
index 37d8922..0c407a3 100644
--- a/lib/until.js
+++ b/lib/until.js
@@ -22,6 +22,7 @@ import wrapAsync from './internal/wrapAsync';
  * function has passed and repeated execution of `iteratee` has stopped. `callback`
  * will be passed an error and any arguments passed to the final `iteratee`'s
  * callback. Invoked with (err, [results]);
+ * @returns {Promise} a promise, if a callback is not passed
  *
  * @example
  * const results = []
@@ -39,5 +40,5 @@ import wrapAsync from './internal/wrapAsync';
  */
 export default function until(test, iteratee, callback) {
     const _test = wrapAsync(test)
-    whilst((cb) => _test((err, truth) => cb (err, !truth)), iteratee, callback);
+    return whilst((cb) => _test((err, truth) => cb (err, !truth)), iteratee, callback);
 }
diff --git a/lib/waterfall.js b/lib/waterfall.js
index f4c3ddc..f9a6c24 100644
--- a/lib/waterfall.js
+++ b/lib/waterfall.js
@@ -1,8 +1,8 @@
-import noop from './internal/noop';
 import once from './internal/once';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify'
 
 /**
  * Runs the `tasks` array of functions in series, each passing their results to
@@ -61,8 +61,8 @@ import wrapAsync from './internal/wrapAsync';
  *     callback(null, 'done');
  * }
  */
-export default  function(tasks, callback) {
-    callback = once(callback || noop);
+function waterfall (tasks, callback) {
+    callback = once(callback);
     if (!Array.isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));
     if (!tasks.length) return callback();
     var taskIndex = 0;
@@ -82,3 +82,5 @@ export default  function(tasks, callback) {
 
     nextTask([]);
 }
+
+export default awaitify(waterfall)
diff --git a/lib/whilst.js b/lib/whilst.js
index d42e6a7..1013d37 100644
--- a/lib/whilst.js
+++ b/lib/whilst.js
@@ -1,7 +1,6 @@
-import noop from './internal/noop';
-
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
+import awaitify from './internal/awaitify';
 
 /**
  * Repeatedly call `iteratee`, while `test` returns `true`. Calls `callback` when
@@ -20,7 +19,7 @@ import wrapAsync from './internal/wrapAsync';
  * function has failed and repeated execution of `iteratee` has stopped. `callback`
  * will be passed an error and any arguments passed to the final `iteratee`'s
  * callback. Invoked with (err, [results]);
- * @returns undefined
+ * @returns {Promise} a promise, if no callback is passed
  * @example
  *
  * var count = 0;
@@ -37,8 +36,8 @@ import wrapAsync from './internal/wrapAsync';
  *     }
  * );
  */
-export default function whilst(test, iteratee, callback) {
-    callback = onlyOnce(callback || noop);
+function whilst(test, iteratee, callback) {
+    callback = onlyOnce(callback);
     var _fn = wrapAsync(iteratee);
     var _test = wrapAsync(test);
     var results
@@ -59,3 +58,4 @@ export default function whilst(test, iteratee, callback) {
 
     return _test(check);
 }
+export default awaitify(whilst, 3)