Fixed "only-arrow-functions" lint rule

types/async/test/es6-generators.ts

@@ -14,41 +14,41 @@ async.map(collectionGenerator(), funcMapIterator, funcMapComplete);
 async.mapSeries(collectionGenerator(), funcMapIterator, funcMapComplete);
 async.mapLimit(collectionGenerator(), 2, funcMapIterator, funcMapComplete);
 
-async.filter(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.filterSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.filterLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { });
-async.select(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.selectSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.selectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { });
+async.filter(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.filterSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.filterLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { });
+async.select(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.selectSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.selectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { });
 
-async.reject(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.rejectSeries(collectionGenerator(), booleanIterator, function(err: Error, results: any[]) { });
-async.rejectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, results: any[]) { });
+async.reject(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.rejectSeries(collectionGenerator(), booleanIterator, (err: Error, results: any[]) => { });
+async.rejectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, results: any[]) => { });
 
-async.each(collectionGenerator(), eachIterator, function(err: Error) { });
-async.eachLimit(collectionGenerator(), 2, eachIterator, function(err: Error) { });
-async.eachSeries(collectionGenerator(), eachIterator, function(err: Error) { });
-async.eachOf(collectionGenerator(), eachOfIterator, function(err: Error) { });
-async.eachOfLimit(collectionGenerator(), 2, eachOfIterator, function(err: Error) { });
-async.eachOfSeries(collectionGenerator(), eachOfIterator, function(err: Error) { });
-async.forEach(collectionGenerator(), eachIterator, function(err: Error) { });
-async.forEachLimit(collectionGenerator(), 2, eachIterator, function(err: Error) { });
-async.forEachSeries(collectionGenerator(), eachIterator, function(err: Error) { });
-async.forEachOf(collectionGenerator(), eachOfIterator, function(err: Error) { });
-async.forEachOfLimit(collectionGenerator(), 2, eachOfIterator, function(err: Error) { });
-async.forEachOfSeries(collectionGenerator(), eachOfIterator, function(err: Error) { });
+async.each(collectionGenerator(), eachIterator, (err: Error) => { });
+async.eachLimit(collectionGenerator(), 2, eachIterator, (err: Error) => { });
+async.eachSeries(collectionGenerator(), eachIterator, (err: Error) => { });
+async.eachOf(collectionGenerator(), eachOfIterator, (err: Error) => { });
+async.eachOfLimit(collectionGenerator(), 2, eachOfIterator, (err: Error) => { });
+async.eachOfSeries(collectionGenerator(), eachOfIterator, (err: Error) => { });
+async.forEach(collectionGenerator(), eachIterator, (err: Error) => { });
+async.forEachLimit(collectionGenerator(), 2, eachIterator, (err: Error) => { });
+async.forEachSeries(collectionGenerator(), eachIterator, (err: Error) => { });
+async.forEachOf(collectionGenerator(), eachOfIterator, (err: Error) => { });
+async.forEachOfLimit(collectionGenerator(), 2, eachOfIterator, (err: Error) => { });
+async.forEachOfSeries(collectionGenerator(), eachOfIterator, (err: Error) => { });
 
-async.every(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
-async.everyLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { });
-async.everySeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
+async.every(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
+async.everyLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { });
+async.everySeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
 
-async.some(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
-async.someLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { });
-async.someSeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
+async.some(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
+async.someLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { });
+async.someSeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
 
-async.detect(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
-async.detectLimit(collectionGenerator(), 2, booleanIterator, function(err: Error, res: boolean) { });
-async.detectSeries(collectionGenerator(), booleanIterator, function(err: Error, res: boolean) { });
+async.detect(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
+async.detectLimit(collectionGenerator(), 2, booleanIterator, (err: Error, res: boolean) => { });
+async.detectSeries(collectionGenerator(), booleanIterator, (err: Error, res: boolean) => { });
 
 async.concat(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { });
 async.concatSeries(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { });

types/async/test/explicit.ts

@@ -2,19 +2,11 @@ interface StringCallback { (err?: Error, result?: string): void; }
 interface AsyncStringGetter { (callback: StringCallback): void; }
 
 const taskArray: AsyncStringGetter[] = [
-    function(callback) {
-        setTimeout(function() {
-            callback(undefined, 'one');
-        }, 200);
-    },
-    function(callback) {
-        setTimeout(function() {
-            callback(undefined, 'two');
-        }, 100);
-    },
+    callback => { setTimeout(() => { callback(undefined, 'one'); }, 200); },
+    callback => { setTimeout(() => { callback(undefined, 'two'); }, 100); }
 ];
 
-async.series(taskArray, function(err, results) {
+async.series(taskArray, (err, results) => {
     if (results) {
         const first = results[0];
         if (first) {
@@ -22,7 +14,8 @@ async.series(taskArray, function(err, results) {
         }
     }
 });
-async.parallel(taskArray, function(err, results) {
+
+async.parallel(taskArray, (err, results) => {
     if (results) {
         const first = results[0];
         if (first) {
@@ -30,7 +23,8 @@ async.parallel(taskArray, function(err, results) {
         }
     }
 });
-async.parallelLimit(taskArray, 3, function(err, results) {
+
+async.parallelLimit(taskArray, 3, (err, results) => {
     if (results) {
         const first = results[0];
         if (first) {
@@ -44,27 +38,21 @@ interface NumberCallback { (err?: Error, result?: number): void; }
 interface AsyncNumberGetter { (callback: NumberCallback): void; }
 
 const taskDict: Lookup<AsyncNumberGetter> = {
-    one: callback => {
-        setTimeout(function() {
-            callback(undefined, 1);
-        }, 200);
-    },
-    two: callback => {
-        setTimeout(function() {
-            callback(undefined, 2);
-        }, 100);
-    }
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
 };
 
-async.series(taskDict, function(err, results) {
+async.series(taskDict, (err, results) => {
     const one = results['one'];
     console.log(one && one.toFixed(1));
 });
-async.parallel(taskDict, function(err, results) {
+
+async.parallel(taskDict, (err, results) => {
     const one = results['one'];
     console.log(one && one.toFixed(1));
 });
-async.parallelLimit(taskDict, 3, function(err, results) {
+
+async.parallelLimit(taskDict, 3, (err, results) => {
     const one = results['one'];
     console.log(one && one.toFixed(1));
 });

types/async/tslint.json

@@ -3,7 +3,6 @@
     "rules": {
         "ban-types": true,                     // PRODUCES ERRORS WHEN REMOVED
         "callable-types": false,               // HAS ISSUES
-        "no-unnecessary-generics": false,      // HAS ISSUES
-        "only-arrow-functions": false          // HAS ISSUES
+        "no-unnecessary-generics": false       // HAS ISSUES
     }
 }