From ee45d6ce05b45fe63e7e82cd38656b93171dbcb4 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Mills <pierreantoine.urvoy@gmail.com>
Date: Fri, 23 Aug 2019 17:33:05 +0200
Subject: [PATCH] fix(ramda): bump ts-toolbelt version, restore broken examples
 (#37849)

* revert broken curry tests, upgrade ts-toolbelt

* fix typo

* fix typo
---
 types/ramda/package.json   |   2 +-
 types/ramda/ramda-tests.ts |  22 +++++---
 types/ramda/tools.d.ts     | 111 -------------------------------------
 3 files changed, 15 insertions(+), 120 deletions(-)

diff --git a/types/ramda/package.json b/types/ramda/package.json
index a8df43e850..57a474b0ef 100644
--- a/types/ramda/package.json
+++ b/types/ramda/package.json
@@ -1,6 +1,6 @@
 {
     "private": true,
     "dependencies": {
-        "ts-toolbelt": "^3.2.22"
+        "ts-toolbelt": "^3.8.4"
     }
 }
diff --git a/types/ramda/ramda-tests.ts b/types/ramda/ramda-tests.ts
index c085e45a89..b01a39b63b 100644
--- a/types/ramda/ramda-tests.ts
+++ b/types/ramda/ramda-tests.ts
@@ -74,14 +74,20 @@ class F2 {
 
     const x1: (a: number, b: number, c: number, d: number) => number = R.curry(addFourNumbers);
     // because of the current way of currying, the following call results in a type error
-    // const x2: Function = R.curry(addFourNumbers)(1,2,4)
-    // const x3: (c: number, d: number) => number = R.curry(addFourNumbers)(1)(2);
-    // const x4: (d: number) => number = R.curry(addFourNumbers)(1)(2)(3);
-    const y1: number   = R.curry(addFourNumbers)(1)(2)(3)(4);
-    const y2: number   = R.curry(addFourNumbers)(1, 2)(3, 4);
-    const y3: number   = R.curry(addFourNumbers)(1, 2, 3)(4);
-    const y4: number   = R.curry(addTenFixedNumbers)(R.__, 1, 2)(0)(3)(R.__, R.__)(R.__, 5)(4)(6, 7)(R.__)(8, R.__, R.__)(9, 10);
-    const y5: number   = R.curry(addTenFixedNumbers)(R.__, 1, R.__)(R.__, 2)(0, 3)(R.__, 5)(4, R.__)(R.__)(6, R.__, 8, 9, 10)(7);
+    const x2: (...args: any) => any = R.curry(addFourNumbers)(1, 2, 4);
+    const x3: (c: number, d: number) => number = R.curry(addFourNumbers)(1)(2);
+    const x4: (d: number) => number = R.curry(addFourNumbers)(1)(2)(3);
+    const y1: number = R.curry(addFourNumbers)(1)(2)(3)(4);
+    const y2: number = R.curry(addFourNumbers)(1, 2)(3, 4);
+    const y3: number = R.curry(addFourNumbers)(1, 2, 3)(4);
+    const y4: number = R.curry(addTenFixedNumbers)(R.__, 1, 2)(0)(3)(
+      R.__,
+      R.__,
+    )(R.__, 5)(4)(6, 7)(R.__)(8, R.__, R.__)(9, 10);
+    const y5: number = R.curry(addTenFixedNumbers)(R.__, 1, R.__)(R.__, 2)(
+      0,
+      3,
+    )(R.__, 5)(4, R.__)(R.__)(6, R.__, 8, 9, 10)(7);
 
     R.nAry(0);
     R.nAry(0, takesNoArg);
diff --git a/types/ramda/tools.d.ts b/types/ramda/tools.d.ts
index 4739288851..b15b813e7d 100644
--- a/types/ramda/tools.d.ts
+++ b/types/ramda/tools.d.ts
@@ -1,116 +1,5 @@
 /// <reference path="./index.d.ts" />
 
-// All the following types are explained here:
-// https://medium.freecodecamp.org/typescript-curry-ramda-types-f747e99744ab
-// https://github.com/pirix-gh/medium/blob/master/types-curry-ramda/src/index.ts
 declare namespace Tools {
-    type Head<T extends any[]> =
-        T extends [any, ...any[]]
-        ? T[0]
-        : never;
-
-    type Tail<T extends any[]> =
-        ((...t: T) => any) extends ((_: any, ...tail: infer TT) => any)
-        ? TT
-        : [];
-
-    type HasTail<T extends any[]> =
-        T extends ([] | [any])
-        ? false
-        : true;
-
-    type Last<T extends any[]> = {
-        0: Last<Tail<T>>;
-        1: Head<T>;
-    }[
-        HasTail<T> extends true
-        ? 0
-        : 1
-    ];
-
-    type Length<T extends any[]> =
-        T['length'];
-
-    type Prepend<E, T extends any[]> =
-        ((head: E, ...args: T) => any) extends ((...args: infer U) => any)
-        ? U
-        : T;
-
-    type Drop<N extends number, T extends any[], I extends any[] = []> = {
-        0: Drop<N, Tail<T>, Prepend<any, I>>;
-        1: T;
-    }[
-        Length<I> extends N
-        ? 1
-        : 0
-    ];
-
-    type Cast<X, Y> = X extends Y ? X : Y;
-
-    type Pos<I extends any[]> =
-        Length<I>;
-
-    type Next<I extends any[]> =
-        Prepend<any, I>;
-
-    type Prev<I extends any[]> =
-        Tail<I>;
-
-    type Iterator<Index extends number = 0, From extends any[] = [], I extends any[] = []> = {
-        0: Iterator<Index, Next<From>, Next<I>>;
-        1: From;
-    }[
-        Pos<I> extends Index
-        ? 1
-        : 0
-    ];
-
-    type Reverse<T extends any[], R extends any[] = [], I extends any[] = []> = {
-        0: Reverse<T, Prepend<T[Pos<I>], R>, Next<I>>;
-        1: R;
-    }[
-        Pos<I> extends Length<T>
-        ? 1
-        : 0
-    ];
-
-    type Concat<T1 extends any[], T2 extends any[]> =
-        Reverse<Reverse<T1> extends infer R ? Cast<R, any[]> : never, T2>;
-
-    type Append<E, T extends any[]> =
-        Concat<T, [E]>;
-
     type ValueOfRecord<R> = R extends Record<any, infer T> ? T : never;
 }
-
-declare namespace Curry {
-    type GapOf<T1 extends any[], T2 extends any[], TN extends any[], I extends any[]> =
-        T1[Tools.Pos<I>] extends R.Placeholder
-        ? Tools.Append<T2[Tools.Pos<I>], TN>
-        : TN;
-
-    type GapsOf<T1 extends any[], T2 extends any[], TN extends any[] = [], I extends any[] = []> = {
-        0: GapsOf<T1, T2, GapOf<T1, T2, TN, I> extends infer G ? Tools.Cast<G, any[]> : never, Tools.Next<I>>;
-        1: Tools.Concat<TN, Tools.Drop<Tools.Pos<I>, T2> extends infer D ? Tools.Cast<D, any[]> : never>;
-    }[
-        Tools.Pos<I> extends Tools.Length<T1>
-        ? 1
-        : 0
-    ];
-
-    type PartialGaps<T extends any[]> = {
-        [K in keyof T]?: T[K] | R.Placeholder
-    };
-
-    type CleanedGaps<T extends any[]> = {
-        [K in keyof T]: NonNullable<T[K]>
-    };
-
-    type Gaps<T extends any[]> = CleanedGaps<PartialGaps<T>>;
-
-    type Curry<F extends ((...args: any) => any)> =
-        <T extends any[]>(...args: Tools.Cast<Tools.Cast<T, Gaps<Parameters<F>>>, any[]>) =>
-            GapsOf<T, Parameters<F>> extends [any, ...any[]]
-            ? Curry<(...args: GapsOf<T, Parameters<F>> extends infer G ? Tools.Cast<G, any[]> : never) => ReturnType<F>>
-            : ReturnType<F>;
-}