From 578aabef155f9aa1d20237face4261ee193c75ef Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Thu, 18 Apr 2019 14:39:40 -0700
Subject: [PATCH] Simplify differenceBy/differenceWith

I only changed the Imp/Exp overloads, because those are the ones that
create significant numbers of types.

The normal case is still fully typed, but when passing multiple
comparison arrays, they are all typed as `List<unknown>`, and the
iteratee is not checked for compatibility with their types.

You should never use multiple comparison arrays.

Brings type count down 18k, from 452k to 434k.
---
 types/lodash/common/array.d.ts | 26 ++++++--------------------
 types/lodash/lodash-tests.ts   | 12 ++++++------
 2 files changed, 12 insertions(+), 26 deletions(-)

diff --git a/types/lodash/common/array.d.ts b/types/lodash/common/array.d.ts
index 4e7bf47511..9e6bd31c9f 100644
--- a/types/lodash/common/array.d.ts
+++ b/types/lodash/common/array.d.ts
@@ -46,22 +46,12 @@ declare module "../index" {
         differenceBy<T>( array: List<T> | null | undefined, ...values: Array<List<T>> ): T[];
     }
     interface Imp<TValue> {
-        differenceBy<T1, T2>( this: Imp<List<T1> | null | undefined>, values: List<T2>, iteratee: ValueIteratee<T1 | T2> ): Imp<T1[]>;
-        differenceBy<T1, T2, T3>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, iteratee: ValueIteratee<T1 | T2 | T3> ): Imp<T1[]>;
-        differenceBy<T1, T2, T3, T4>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, iteratee: ValueIteratee<T1 | T2 | T3 | T4> ): Imp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5> ): Imp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5, T6>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, values5: List<T6>, iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6> ): Imp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5, T6, T7>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, values5: List<T6>, ...values: Array<List<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>> ): Imp<T1[]>;
-        differenceBy<T>( this: Imp<List<T> | null | undefined>, ...values: Array<List<T>> ): Imp<T[]>;
+        differenceBy<T1, T2>( this: Imp<List<T1> | null | undefined>, values1: T2, iteratee?: ValueIteratee<T1 | T2> ): Imp<T1[]>;
+        differenceBy<T>( this: Imp<List<T> | null | undefined>, ...values: Array<List<unknown> | ValueIteratee<T>> ): Imp<T[]>;
     }
     interface Exp<TValue> {
-        differenceBy<T1, T2>( this: Exp<List<T1> | null | undefined>, values: List<T2>, iteratee: ValueIteratee<T1 | T2> ): Exp<T1[]>;
-        differenceBy<T1, T2, T3>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, iteratee: ValueIteratee<T1 | T2 | T3> ): Exp<T1[]>;
-        differenceBy<T1, T2, T3, T4>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, iteratee: ValueIteratee<T1 | T2 | T3 | T4> ): Exp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5> ): Exp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5, T6>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, values5: List<T6>, iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6> ): Exp<T1[]>;
-        differenceBy<T1, T2, T3, T4, T5, T6, T7>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, values3: List<T4>, values4: List<T5>, values5: List<T6>, ...values: Array<List<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>> ): Exp<T1[]>;
-        differenceBy<T>( this: Exp<List<T> | null | undefined>, ...values: Array<List<T>> ): Exp<T[]>;
+        differenceBy<T1, T2>( this: Exp<List<T1> | null | undefined>, values1: T2, iteratee?: ValueIteratee<T1 | T2> ): Exp<T1[]>;
+        differenceBy<T>(this: Exp<List<T> | null | undefined>, ...values: Array<List<unknown> | ValueIteratee<T>> ): Exp<T[]>;
     }
     interface Stat {
         differenceWith<T1, T2>( array: List<T1> | null | undefined, values: List<T2>, comparator: Comparator2<T1, T2> ): T1[];
@@ -71,15 +61,11 @@ declare module "../index" {
     }
     interface Imp<TValue> {
         differenceWith<T1, T2>( this: Imp<List<T1> | null | undefined>, values: List<T2>, comparator: Comparator2<T1, T2> ): Imp<T1[]>;
-        differenceWith<T1, T2, T3>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, comparator: Comparator2<T1, T2 | T3> ): Imp<T1[]>;
-        differenceWith<T1, T2, T3, T4>( this: Imp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>> ): Imp<T1[]>;
-        differenceWith<T>( this: Imp<List<T> | null | undefined>, ...values: Array<List<T>> ): Imp<T[]>;
+        differenceWith<T1, T2, T3, T4>( this: Imp<List<T1> | null | undefined>, ...values: Array<List<unknown> | Comparator2<T1, never>> ): Imp<T1[]>;
     }
     interface Exp<TValue> {
         differenceWith<T1, T2>( this: Exp<List<T1> | null | undefined>, values: List<T2>, comparator: Comparator2<T1, T2> ): Exp<T1[]>;
-        differenceWith<T1, T2, T3>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, comparator: Comparator2<T1, T2 | T3> ): Exp<T1[]>;
-        differenceWith<T1, T2, T3, T4>( this: Exp<List<T1> | null | undefined>, values1: List<T2>, values2: List<T3>, ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>> ): Exp<T1[]>;
-        differenceWith<T>( this: Exp<List<T> | null | undefined>, ...values: Array<List<T>> ): Exp<T[]>;
+        differenceWith<T1, T2, T3, T4>( this: Exp<List<T1> | null | undefined>, ...values: Array<List<unknown> | Comparator2<T1, never>> ): Exp<T1[]>;
     }
     interface Stat {
         drop<T>(array: List<T> | null | undefined, n?: number): T[];
diff --git a/types/lodash/lodash-tests.ts b/types/lodash/lodash-tests.ts
index bbf12098e4..4d29437c5d 100644
--- a/types/lodash/lodash-tests.ts
+++ b/types/lodash/lodash-tests.ts
@@ -115,17 +115,17 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType LoDashExplicitWrapper<number
     _(list).differenceBy(listParam, valueIterator); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, valueIterator); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     // $ExpectType LoDashImplicitWrapper<AbcObject[]>
-    _(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, valueIterator);
+    _(list).differenceBy<AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, valueIterator);
 
     _(list).differenceBy(listParam, "a"); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, "a"); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     // $ExpectType LoDashImplicitWrapper<AbcObject[]>
-    _(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, "a");
+    _(list).differenceBy<AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, "a");
 
     _(list).differenceBy(listParam, {a: 1}); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     _(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, {a: 1}); // $ExpectType LoDashImplicitWrapper<AbcObject[]>
     // $ExpectType LoDashImplicitWrapper<AbcObject[]>
-    _(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, {a: 1});
+    _(list).differenceBy<AbcObject>(arrayParam, listParam, arrayParam, listParam, arrayParam, listParam, {a: 1});
 
     _.chain(list).differenceBy(arrayParam); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     _.chain(list).differenceBy(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
@@ -133,17 +133,17 @@ _.chain([1, 2, 3, 4]).unshift(5, 6); // $ExpectType LoDashExplicitWrapper<number
     _.chain(list).differenceBy(arrayParam, valueIterator); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, valueIterator); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     // $ExpectType LoDashExplicitWrapper<AbcObject[]>
-    _.chain(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, valueIterator);
+    _.chain(list).differenceBy<AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, valueIterator);
 
     _.chain(list).differenceBy(arrayParam, "a"); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, "a"); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     // $ExpectType LoDashExplicitWrapper<AbcObject[]>
-    _.chain(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, "a");
+    _.chain(list).differenceBy<AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, "a");
 
     _.chain(list).differenceBy(arrayParam, {a: 1}); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     _.chain(list).differenceBy(arrayParam, listParam, arrayParam, listParam, arrayParam, {a: 1}); // $ExpectType LoDashExplicitWrapper<AbcObject[]>
     // $ExpectType LoDashExplicitWrapper<AbcObject[]>
-    _.chain(list).differenceBy<AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject, AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, {a: 1});
+    _.chain(list).differenceBy<AbcObject>(listParam, arrayParam, listParam, arrayParam, listParam, arrayParam, {a: 1});
 
     fp.differenceBy(valueIterator, list, arrayParam); // $ExpectType AbcObject[]
     fp.differenceBy<AbcObject, AbcObject>(valueIterator)(list)(listParam); // $ExpectType AbcObject[]