use rest params instead of slice

22 files changed, 54 insertions, 136 deletions

diff --git a/lib/apply.js b/lib/apply.js
index 06f630a..e6775e2 100644
--- a/lib/apply.js
+++ b/lib/apply.js
@@ -1,5 +1,3 @@
-import slice from './internal/slice';
-
 /**
  * Creates a continuation function with some arguments already applied.
  *
@@ -45,10 +43,8 @@ import slice from './internal/slice';
  * two
  * three
  */
-export default function(fn/*, ...args*/) {
-    var args = slice(arguments, 1);
-    return function(/*callArgs*/) {
-        var callArgs = slice(arguments);
+export default function(fn, ...args) {
+    return function(...callArgs) {
         return fn.apply(null, args.concat(callArgs));
     };
 };
diff --git a/lib/auto.js b/lib/auto.js
index 0175fda..e7f8813 100644
--- a/lib/auto.js
+++ b/lib/auto.js
@@ -1,7 +1,6 @@
 import noop from './internal/noop';
 
 import forOwn from './internal/forOwn';
-import slice from './internal/slice';
 import once from './internal/once';
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -188,14 +187,14 @@ export default function (tasks, concurrency, callback) {
     function runTask(key, task) {
         if (hasError) return;
 
-        var taskCallback = onlyOnce(function(err, result) {
+        var taskCallback = onlyOnce(function(err, ...result) {
             runningTasks--;
             if (err === false) {
                 canceled = true
                 return
             }
-            if (arguments.length > 2) {
-                result = slice(arguments, 1);
+            if (result.length < 2) {
+                result = result[0];
             }
             if (err) {
                 var safeResults = {};
diff --git a/lib/autoInject.js b/lib/autoInject.js
index 65b2cfb..2f1c38c 100644
--- a/lib/autoInject.js
+++ b/lib/autoInject.js
@@ -111,8 +111,8 @@ export default function autoInject(tasks, callback) {
             (fnIsAsync && taskFn.length === 0);
 
         if (Array.isArray(taskFn)) {
-            params = taskFn.slice(0, -1);
-            taskFn = taskFn[taskFn.length - 1];
+            params = [...taskFn];
+            taskFn = params.pop();
 
             newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
         } else if (hasNoDeps) {
diff --git a/lib/compose.js b/lib/compose.js
index d9fa760..373dc3a 100644
--- a/lib/compose.js
+++ b/lib/compose.js
@@ -1,5 +1,4 @@
 import seq from './seq';
-import slice from './internal/slice';
 
 /**
  * Creates a function which is a composition of the passed asynchronous
@@ -36,6 +35,6 @@ import slice from './internal/slice';
  *     // result now equals 15
  * });
  */
-export default function(/*...args*/) {
-    return seq.apply(null, slice(arguments).reverse());
+export default function(...args) {
+    return seq.apply(null, args.reverse());
 };
diff --git a/lib/concatLimit.js b/lib/concatLimit.js
index cec4e2b..3a432c3 100644
--- a/lib/concatLimit.js
+++ b/lib/concatLimit.js
@@ -1,6 +1,5 @@
 import noop from './internal/noop';
 import wrapAsync from './internal/wrapAsync';
-import slice from './internal/slice';
 import mapLimit from './mapLimit';
 
 var _concat = Array.prototype.concat;
@@ -27,9 +26,9 @@ export default function(coll, limit, iteratee, callback) {
     callback = callback || noop;
     var _iteratee = wrapAsync(iteratee);
     mapLimit(coll, limit, function(val, callback) {
-        _iteratee(val, function(err /*, ...args*/) {
+        _iteratee(val, function(err, ...args) {
             if (err) return callback(err);
-            return callback(null, slice(arguments, 1));
+            return callback(null, args);
         });
     }, function(err, mapResults) {
         var result = [];
diff --git a/lib/constant.js b/lib/constant.js
index 238ef61..4ad80b7 100644
--- a/lib/constant.js
+++ b/lib/constant.js
@@ -1,5 +1,3 @@
-import slice from './internal/slice';
-
 /**
  * Returns a function that when called, calls-back with the values provided.
  * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to
@@ -42,11 +40,10 @@ import slice from './internal/slice';
  *     //...
  * }, callback);
  */
-export default function(/*...values*/) {
-    var values = slice(arguments);
+export default function(...values) {
     var args = [null].concat(values);
-    return function (/*...ignoredArgs, callback*/) {
-        var callback = arguments[arguments.length - 1];
+    return function (...ignoredArgs/*, callback*/) {
+        var callback = ignoredArgs[ignoredArgs.length - 1];
         return callback.apply(this, args);
     };
 };
diff --git a/lib/doDuring.js b/lib/doDuring.js
index 5eb2b92..c852796 100644
--- a/lib/doDuring.js
+++ b/lib/doDuring.js
@@ -1,5 +1,4 @@
 import noop from './internal/noop';
-import slice from './internal/slice';
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
 
@@ -28,10 +27,9 @@ export default function doDuring(fn, test, callback) {
     var _fn = wrapAsync(fn);
     var _test = wrapAsync(test);
 
-    function next(err/*, ...args*/) {
+    function next(err, ...args) {
         if (err) return callback(err);
         if (err === false) return;
-        var args = slice(arguments, 1);
         args.push(check);
         _test.apply(this, args);
     };
diff --git a/lib/doWhilst.js b/lib/doWhilst.js
index 5245820..de03699 100644
--- a/lib/doWhilst.js
+++ b/lib/doWhilst.js
@@ -1,5 +1,4 @@
 import noop from './internal/noop';
-import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -29,12 +28,11 @@ import wrapAsync from './internal/wrapAsync';
 export default function doWhilst(iteratee, test, callback) {
     callback = onlyOnce(callback || noop);
     var _iteratee = wrapAsync(iteratee);
-    var next = function(err/*, ...args*/) {
+    var next = function(err, ...args) {
         if (err) return callback(err);
         if (err === false) return;
-        var args = slice(arguments, 1);
         if (test.apply(this, args)) return _iteratee(next);
-        callback.apply(null, [null].concat(args));
+        callback(null, ...args);
     };
     _iteratee(next);
 }
diff --git a/lib/internal/applyEach.js b/lib/internal/applyEach.js
index c0ed402..08ddbd3 100644
--- a/lib/internal/applyEach.js
+++ b/lib/internal/applyEach.js
@@ -1,10 +1,8 @@
-import slice from './slice';
 import initialParams from './initialParams';
 import wrapAsync from './wrapAsync';
 
 export default function applyEach(eachfn) {
-    return function(fns/*, ...args*/) {
-        var args = slice(arguments, 1);
+    return function(fns, ...args) {
         var go = initialParams(function(args, callback) {
             var that = this;
             return eachfn(fns, function (fn, cb) {
diff --git a/lib/internal/consoleFunc.js b/lib/internal/consoleFunc.js
index c977647..d1d5d4d 100644
--- a/lib/internal/consoleFunc.js
+++ b/lib/internal/consoleFunc.js
@@ -1,23 +1,20 @@
-import slice from './slice';
 import wrapAsync from './wrapAsync';
 
 export default function consoleFunc(name) {
-    return function (fn/*, ...args*/) {
-        var args = slice(arguments, 1);
-        args.push(function (err/*, ...args*/) {
-            var args = slice(arguments, 1);
+    return function (fn, ...args) {
+        args.push(function (err, ...resultArgs) {
             if (typeof console === 'object') {
                 if (err) {
                     if (console.error) {
                         console.error(err);
                     }
                 } else if (console[name]) {
-                    args.forEach(function (x) {
+                    resultArgs.forEach(function (x) {
                         console[name](x);
                     });
                 }
             }
         })
-        wrapAsync(fn).apply(null, args);
+        wrapAsync(fn)(...args);
     };
 }
diff --git a/lib/internal/initialParams.js b/lib/internal/initialParams.js
index 2079703..4014785 100644
--- a/lib/internal/initialParams.js
+++ b/lib/internal/initialParams.js
@@ -1,8 +1,5 @@
-import slice from './slice';
-
 export default function (fn) {
-    return function (/*...args, callback*/) {
-        var args = slice(arguments);
+    return function (...args/*, callback*/) {
         var callback = args.pop();
         fn.call(this, args, callback);
     };
diff --git a/lib/internal/parallel.js b/lib/internal/parallel.js
index bbfdb42..6246d8f 100644
--- a/lib/internal/parallel.js
+++ b/lib/internal/parallel.js
@@ -1,6 +1,5 @@
 import isArrayLike from './isArrayLike';
 import noop from './noop';
-import slice from './slice';
 import wrapAsync from './wrapAsync';
 
 export default function _parallel(eachfn, tasks, callback) {
@@ -8,9 +7,9 @@ export default function _parallel(eachfn, tasks, callback) {
     var results = isArrayLike(tasks) ? [] : {};
 
     eachfn(tasks, function (task, key, callback) {
-        wrapAsync(task)(function (err, result) {
-            if (arguments.length > 2) {
-                result = slice(arguments, 1);
+        wrapAsync(task)(function (err, ...result) {
+            if (result.length < 2) {
+                result = result[0];
             }
             results[key] = result;
             callback(err);
diff --git a/lib/internal/setImmediate.js b/lib/internal/setImmediate.js
index 95191f9..86e15a7 100644
--- a/lib/internal/setImmediate.js
+++ b/lib/internal/setImmediate.js
@@ -1,7 +1,5 @@
 'use strict';
 
-import slice from './slice';
-
 export var hasSetImmediate = typeof setImmediate === 'function' && setImmediate;
 export var hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';
 
@@ -10,10 +8,9 @@ export function fallback(fn) {
 }
 
 export function wrap(defer) {
-    return function (fn/*, ...args*/) {
-        var args = slice(arguments, 1);
+    return function (fn, ...args) {
         defer(function () {
-            fn.apply(null, args);
+            fn(...args);
         });
     };
 }
diff --git a/lib/internal/slice.js b/lib/internal/slice.js
deleted file mode 100644
index cd2e5b3..0000000
--- a/lib/internal/slice.js
+++ /dev/null
@@ -1,9 +0,0 @@
-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;
-}
diff --git a/lib/memoize.js b/lib/memoize.js
index ea0da43..84526c3 100644
--- a/lib/memoize.js
+++ b/lib/memoize.js
@@ -1,5 +1,4 @@
 import identity from './internal/identity';
-import slice from './internal/slice';
 import setImmediate from './internal/setImmediate';
 import initialParams from './internal/initialParams';
 import wrapAsync from './internal/wrapAsync';
@@ -63,17 +62,16 @@ export default function memoize(fn, hasher) {
             queues[key].push(callback);
         } else {
             queues[key] = [callback];
-            _fn.apply(null, args.concat(function(/*args*/) {
-                var args = slice(arguments);
-                var err = args[0];
+            _fn.apply(null, args.concat(function(...resultArgs) {
+                var err = resultArgs[0];
                 // #1465 don't memoize if an error occurred
                 if (!err) {
-                    memo[key] = args;
+                    memo[key] = resultArgs;
                 }
                 var q = queues[key];
                 delete queues[key];
                 for (var i = 0, l = q.length; i < l; i++) {
-                    q[i].apply(null, args);
+                    q[i].apply(null, resultArgs);
                 }
             }));
         }
diff --git a/lib/reduceRight.js b/lib/reduceRight.js
index 1d203c9..dd56a88 100644
--- a/lib/reduceRight.js
+++ b/lib/reduceRight.js
@@ -1,5 +1,4 @@
 import reduce from './reduce';
-import slice from './internal/slice';
 
 /**
  * Same as [`reduce`]{@link module:Collections.reduce}, only operates on `array` in reverse order.
@@ -24,6 +23,6 @@ import slice from './internal/slice';
  * (err, result).
  */
 export default function reduceRight (array, memo, iteratee, callback) {
-    var reversed = slice(array).reverse();
+    var reversed = [...array].reverse();
     reduce(reversed, memo, iteratee, callback);
 }
diff --git a/lib/reflect.js b/lib/reflect.js
index f50d817..75f71d5 100644
--- a/lib/reflect.js
+++ b/lib/reflect.js
@@ -1,5 +1,4 @@
 import initialParams from './internal/initialParams';
-import slice from './internal/slice';
 import wrapAsync from './internal/wrapAsync';
 
 /**
@@ -44,18 +43,15 @@ import wrapAsync from './internal/wrapAsync';
 export default function reflect(fn) {
     var _fn = wrapAsync(fn);
     return initialParams(function reflectOn(args, reflectCallback) {
-        args.push(function callback(error, cbArg) {
+        args.push(function callback(error, ...cbArgs) {
             if (error) {
-                reflectCallback(null, { error: error });
-            } else {
-                var value;
-                if (arguments.length <= 2) {
-                    value = cbArg
-                } else {
-                    value = slice(arguments, 1);
-                }
-                reflectCallback(null, { value: value });
+                return reflectCallback(null, { error });
             }
+            var value = cbArgs;
+            if (cbArgs.length <= 1) {
+                value = cbArgs[0]
+            }
+            reflectCallback(null, { value });
         });
 
         return _fn.apply(this, args);
diff --git a/lib/seq.js b/lib/seq.js
index 5672195..c36978e 100644
--- a/lib/seq.js
+++ b/lib/seq.js
@@ -1,5 +1,4 @@
 import noop from './internal/noop';
-import slice from './internal/slice';
 import reduce from './reduce';
 import wrapAsync from './internal/wrapAsync';
 
@@ -41,10 +40,9 @@ import wrapAsync from './internal/wrapAsync';
  *     });
  * });
  */
-export default function seq(/*...functions*/) {
-    var _functions = Array.prototype.map.call(arguments, wrapAsync);
-    return function(/*...args*/) {
-        var args = slice(arguments);
+export default function seq(...functions) {
+    var _functions = functions.map(wrapAsync);
+    return function(...args) {
         var that = this;
 
         var cb = args[args.length - 1];
@@ -55,8 +53,7 @@ export default function seq(/*...functions*/) {
         }
 
         reduce(_functions, args, function(newargs, fn, cb) {
-            fn.apply(that, newargs.concat(function(err/*, ...nextargs*/) {
-                var nextargs = slice(arguments, 1);
+            fn.apply(that, newargs.concat(function(err, ...nextargs) {
                 cb(err, nextargs);
             }));
         },
diff --git a/lib/tryEach.js b/lib/tryEach.js
index 82649b4..8b45984 100644
--- a/lib/tryEach.js
+++ b/lib/tryEach.js
@@ -1,7 +1,6 @@
 import eachSeries from './eachSeries';
 import noop from './internal/noop';
 import wrapAsync from './internal/wrapAsync';
-import slice from './internal/slice';
 
 /**
  * It runs each task in series but stops whenever any of the functions were
@@ -45,11 +44,11 @@ export default function tryEach(tasks, callback) {
     var result;
     callback = callback || noop;
     eachSeries(tasks, function(task, callback) {
-        wrapAsync(task)(function (err, res/*, ...args*/) {
-            if (arguments.length > 2) {
-                result = slice(arguments, 1);
+        wrapAsync(task)(function (err, ...args) {
+            if (args.length < 2) {
+                result = args[0];
             } else {
-                result = res;
+                result = args;
             }
             error = err;
             callback(err ? null : {});
diff --git a/lib/waterfall.js b/lib/waterfall.js
index 807d2ac..5329e33 100644
--- a/lib/waterfall.js
+++ b/lib/waterfall.js
@@ -1,6 +1,5 @@
 import noop from './internal/noop';
 import once from './internal/once';
-import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -71,19 +70,18 @@ export default  function(tasks, callback) {
 
     function nextTask(args) {
         var task = wrapAsync(tasks[taskIndex++]);
-        args.push(onlyOnce(next));
-        task.apply(null, args);
+        task(...args, onlyOnce(next));
     }
 
-    function next(err/*, ...args*/) {
+    function next(err, ...args) {
         if (err === false || canceled) {
             canceled = true
             return
         }
         if (err || taskIndex === tasks.length) {
-            return callback.apply(null, arguments);
+            return callback(err, ...args);
         }
-        nextTask(slice(arguments, 1));
+        nextTask(args);
     }
 
     nextTask([]);
diff --git a/lib/whilst.js b/lib/whilst.js
index 32c3b52..046d674 100644
--- a/lib/whilst.js
+++ b/lib/whilst.js
@@ -1,5 +1,4 @@
 import noop from './internal/noop';
-import slice from './internal/slice';
 
 import onlyOnce from './internal/onlyOnce';
 import wrapAsync from './internal/wrapAsync';
@@ -42,12 +41,11 @@ export default function whilst(test, iteratee, callback) {
     callback = onlyOnce(callback || noop);
     var _iteratee = wrapAsync(iteratee);
     if (!test()) return callback(null);
-    var next = function(err/*, ...args*/) {
+    var next = function(err, ...args) {
         if (err) return callback(err);
         if (err === false) return;
         if (test()) return _iteratee(next);
-        var args = slice(arguments, 1);
-        callback.apply(null, [null].concat(args));
+        callback(null, ...args);
     };
     _iteratee(next);
 }
diff --git a/test/slice.js b/test/slice.js
deleted file mode 100644
index 7020526..0000000
--- a/test/slice.js
+++ /dev/null
@@ -1,32 +0,0 @@
-var slice = require('../lib/internal/slice').default;
-var expect = require('chai').expect;
-
-describe('slice', function() {
-    it('should slice arrays', function() {
-        var arr = ['foo', 'bar', 'baz'];
-        var result = slice(arr, 2);
-        expect(arr).to.eql(['foo', 'bar', 'baz']);
-        expect(result).to.eql(['baz']);
-    });
-
-    it('should handle ArrayLike objects', function() {
-        var args = {0: 'foo', 1: 'bar', 2: 'baz', length: 3};
-        var result = slice(args, 1);
-        expect(result).to.be.an('array');
-        expect(result).to.eql(['bar', 'baz']);
-    });
-
-    it('should handle arguments', function() {
-        var foo = function() {
-            return slice(arguments, 1);
-        };
-        var result = foo.apply(null, ['foo', 'bar', 'baz']);
-        expect(result).to.be.an('array');
-        expect(result).to.eql(['bar', 'baz']);
-    });
-
-    it('should return an empty array on an invalid start', function() {
-        var result = slice(['foo', 'bar', 'baz'], 10);
-        expect(result).to.be.an('array').that.is.empty;
-    });
-});