Merge pull request #31892 from Dmitri1337/master

@typed/async: added "remove" method to "AsyncQueue<T>"

types/async/index.d.ts

@@ -1,13 +1,18 @@
-// Type definitions for Async 2.0.1
+// Type definitions for Async 2.4
 // Project: https://github.com/caolan/async
-// Definitions by: Boris Yankov <https://github.com/borisyankov>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>, Angus Fenying <https://github.com/fenying>, Pascal Martin <https://github.com/pascalmartin>
+// Definitions by: Boris Yankov <https://github.com/borisyankov>
+//                 Arseniy Maximov <https://github.com/kern0>
+//                 Joe Herman <https://github.com/Penryn>
+//                 Angus Fenying <https://github.com/fenying>
+//                 Pascal Martin <https://github.com/pascalmartin>
+//                 Dmitri Trofimov <https://github.com/Dmitri1337>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
 export as namespace async;
 
 export interface Dictionary<T> { [key: string]: T; }
-export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>
+export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>;
 
 export interface ErrorCallback<E = Error> { (err?: E | null): void; }
 export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
@@ -26,30 +31,40 @@ export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncB
 export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
 export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
 
-export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> }
-export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | (keyof R | AsyncAutoTaskFunction<R1, R, E>)[];
+export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> };
+export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | Array<keyof R | AsyncAutoTaskFunction<R1, R, E>>;
 export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
 export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
 
+export interface DataContainer<T> {
+    data: T;
+}
+
+export interface CallbackContainer {
+    callback: Function;
+}
+
+export interface PriorityContainer {
+    priority: number;
+}
+
 export interface AsyncQueue<T> {
     length(): number;
     started: boolean;
     running(): number;
     idle(): boolean;
     concurrency: number;
-    push<R,E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
+    push<R, E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
     unshift<E = Error>(task: T | T[], callback?: ErrorCallback<E>): void;
+    remove(filter: (node: DataContainer<T>) => boolean): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
     paused: boolean;
-    pause(): void
+    pause(): void;
     resume(): void;
     kill(): void;
-    workersList(): {
-        data: T,
-        callback: Function
-    }[];
+    workersList<TWorker extends DataContainer<T>, CallbackContainer>(): TWorker[];
     error(error: Error, data: any): void;
     unsaturated(): void;
     buffer: number;
@@ -60,7 +75,7 @@ export interface AsyncPriorityQueue<T> {
     concurrency: number;
     started: boolean;
     paused: boolean;
-    push<R,E = Error>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
+    push<R, E = Error>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -69,11 +84,7 @@ export interface AsyncPriorityQueue<T> {
     pause(): void;
     resume(): void;
     kill(): void;
-    workersList(): {
-        data: T,
-        priority: number,
-        callback: Function
-    }[];
+    workersList<TWorker extends DataContainer<T>, CallbackContainer, PriorityContainer>(): TWorker[];
     error(error: Error, data: any): void;
     unsaturated(): void;
     buffer: number;
@@ -82,7 +93,7 @@ export interface AsyncPriorityQueue<T> {
 export interface AsyncCargo {
     length(): number;
     payload?: number;
-    push(task: any, callback? : Function): void;
+    push(task: any, callback?: Function): void;
     saturated(): void;
     empty(): void;
     drain(): void;
@@ -105,11 +116,17 @@ export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit:
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
-export function map<T, R, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function map<T, R, E = Error>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: T[] | IterableIterator<T> | Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
 export const mapSeries: typeof map;
 export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function mapValuesLimit<T, R, E = Error>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+
+export function mapValuesLimit<T, R, E = Error>(
+    obj: Dictionary<T>,
+    limit: number,
+    iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void,
+    callback: AsyncResultObjectCallback<R, E>
+    ): void;
+
 export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
 export const mapValuesSeries: typeof mapValues;
 export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
@@ -151,7 +168,7 @@ export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit:
 export const concatSeries: typeof concat;
 
 // Control Flow
-export function series<T, E = Error>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
+export function series<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
 export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
 export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
 export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
@@ -161,9 +178,9 @@ export function whilst<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>,
 export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
 export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function during<E = Error>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function during<E = Error>(test: (testCallback: AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
 export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
-export function forever<E = Error>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
+export function forever<E = Error>(next: (next: ErrorCallback<E>) => void, errBack: ErrorCallback<E>): void;
 export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
@@ -172,34 +189,52 @@ export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): voi
 export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
 export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
 export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
-export function cargo<E = Error>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+export function cargo<E = Error>(worker: (tasks: any[], callback: ErrorCallback<E>) => void, payload?: number): AsyncCargo;
 export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
 export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
 export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-export function retry<T, E = Error>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
-export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
+
+export function retry<T, E = Error>(
+    opts: number | {
+        times: number,
+        interval: number | ((retryCount: number) => number)
+    },
+    task: (callback: AsyncResultCallback<T, E>, results: any) => void,
+    callback: AsyncResultCallback<any, E>
+    ): void;
+
 export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
-export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any,E>;
+export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any, E>;
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E = Error>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
-export function reflectAll<T, E = Error>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
+export function reflect<T, E = Error>(fn: AsyncFunction<T, E>): (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+export function reflectAll<T, E = Error>(tasks: Array<AsyncFunction<T, E>>): Array<(callback: (err: null, result: {error?: E, value?: T}) => void) => void>;
 
 export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
 export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
 
-export function times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function times<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 export function timesSeries<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
 export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E = Error>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
-export function transform<T, R, E = Error>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(
+    arr: {[key: string]: T},
+    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
+    callback?: AsyncResultObjectCallback<T, E>
+    ): void;
 
-export function race<T, E = Error>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
+export function transform<T, R, E = Error>(
+    arr: {[key: string]: T},
+    acc: {[key: string]: R},
+    iteratee: (acc: {[key: string]: R}, item: T, key: string, callback: (error?: E) => void) => void,
+    callback?: AsyncResultObjectCallback<T, E>
+    ): void;
+
+export function race<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback: AsyncResultCallback<T, E>): void;
 
 // Utils
 export function memoize(fn: Function, hasher?: Function): Function;

types/async/test/es6-generators.ts

@@ -10,45 +10,45 @@ function eachOfIterator<T, K, E>(item: T, key: K, callback: (err: Error) => void
 
 function concatIterator<T, R, E>(item: T, callback: (err: E, res: R[]) => void) { }
 
-async.map(collectionGenerator(), funcMapIterator, funcMapComplete)
-async.mapSeries(collectionGenerator(), funcMapIterator, funcMapComplete)
-async.mapLimit(collectionGenerator(), 2, funcMapIterator, funcMapComplete)
+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[]) => { })
+async.concat(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { });
+async.concatSeries(collectionGenerator(), concatIterator, (err: Error, res: any[]) => { });

types/async/test/explicit.ts

@@ -1,74 +1,58 @@
-
-
 interface StringCallback { (err?: Error, result?: string): void; }
 interface AsyncStringGetter { (callback: StringCallback): void; }
 
-var taskArray: AsyncStringGetter[] = [
-    function (callback) {
-        setTimeout(function () {
-            callback(undefined, 'one');
-        }, 200);
-    },
-    function (callback) {
-        setTimeout(function () {
-            callback(undefined, 'two');
-        }, 100);
-    },
+const taskArray: AsyncStringGetter[] = [
+    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) {
-        let first = results[0];
+        const first = results[0];
         if (first) {
-            console.log(first.match(/o/))
-        }
-    }
-});
-async.parallel(taskArray, function (err, results) {
-    if (results) {
-        let first = results[0];
-        if (first) {
-            console.log(first.match(/o/))
-        }
-    }
-});
-async.parallelLimit(taskArray, 3, function (err, results) {
-    if (results) {
-        let first = results[0];
-        if (first) {
-            console.log(first.match(/o/))
+            console.log(first.match(/o/));
         }
     }
 });
 
+async.parallel(taskArray, (err, results) => {
+    if (results) {
+        const first = results[0];
+        if (first) {
+            console.log(first.match(/o/));
+        }
+    }
+});
+
+async.parallelLimit(taskArray, 3, (err, results) => {
+    if (results) {
+        const first = results[0];
+        if (first) {
+            console.log(first.match(/o/));
+        }
+    }
+});
 
 interface Lookup<T> { [key: string]: T; }
 interface NumberCallback { (err?: Error, result?: number): void; }
 interface AsyncNumberGetter { (callback: NumberCallback): void; }
 
-var taskDict: Lookup<AsyncNumberGetter> = {
-    one: function(callback) {
-        setTimeout(function() {
-            callback(undefined, 1);
-        }, 200);
-    },
-    two: function(callback) {
-        setTimeout(function() {
-            callback(undefined, 2);
-        }, 100);
-    }
-}
+const taskDict: Lookup<AsyncNumberGetter> = {
+    one: callback => { setTimeout(() => { callback(undefined, 1); }, 200); },
+    two: callback => { setTimeout(() => { callback(undefined, 2); }, 100); }
+};
 
-async.series(taskDict, function(err, results) {
-    let one = results['one'];
-    console.log(one && one.toFixed(1))
-});
-async.parallel(taskDict, function(err, results) {
-    let one = results['one'];
-    console.log(one && one.toFixed(1))
-});
-async.parallelLimit(taskDict, 3, function(err, results) {
-    let one = results['one'];
-    console.log(one && one.toFixed(1))
+async.series(taskDict, (err, results) => {
+    const one = results['one'];
+    console.log(one && one.toFixed(1));
 });
 
+async.parallel(taskDict, (err, results) => {
+    const one = results['one'];
+    console.log(one && one.toFixed(1));
+});
+
+async.parallelLimit(taskDict, 3, (err, results) => {
+    const one = results['one'];
+    console.log(one && one.toFixed(1));
+});

types/async/tslint.json

@@ -1,34 +1,8 @@
 {
     "extends": "dtslint/dt.json",
     "rules": {
-        // TODOs
-        "arrow-return-shorthand": false,
-        "array-type": false,
-        "ban-types": false,
-        "callable-types": false,
-        "comment-format": false,
-        "dt-header": false,
-        "max-line-length": false,
-        "no-consecutive-blank-lines": false,
-        "no-padding": false,
-        "no-unnecessary-generics": false,
-        "no-var-keyword": false,
-        "no-void-expression": false,
-        "object-literal-key-quotes": false,
-        "object-literal-shorthand": false,
-        "one-line": false,
-        "one-variable-per-declaration": false,
-        "only-arrow-functions": false,
-        "prefer-const": false,
-        "prefer-for-of": false,
-        "prefer-method-signature": false,
-        "prefer-template": false,
-        "semicolon": false,
-        "space-before-function-paren": false,
-        "space-within-parens": false,
-        "trim-file": false,
-        "typedef-whitespace": false,
-        "unified-signatures": false,
-        "whitespace": false
+        "ban-types": true,                     // PRODUCES ERRORS WHEN REMOVED
+        "callable-types": false,               // HAS ISSUES
+        "no-unnecessary-generics": false       // HAS ISSUES
     }
 }