From 2be1dfe8a96e5dfc5d5b12fb99bfddeeab0aea92 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:13:59 +1000
Subject: [PATCH 01/40] refactor(Apply/ap): replace generics `A`/`B` with
 `A1`/`A2`

---
 src/Apply.ts | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Apply.ts b/src/Apply.ts
index d85081e60..8f67651eb 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -113,36 +113,36 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
 export function ap<F extends URIS2, G extends URIS2, E>(
   F: Apply2<F>,
   G: Apply2C<G, E>
-): <FE, A>(
-  fa: Kind2<F, FE, Kind2<G, E, A>>
-) => <B>(fab: Kind2<F, FE, Kind2<G, E, (a: A) => B>>) => Kind2<F, FE, Kind2<G, E, B>>
+): <FE, A1>(
+  fa: Kind2<F, FE, Kind2<G, E, A1>>
+) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
 export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
-): <A>(fa: Kind<F, Kind2<G, E, A>>) => <B>(fab: Kind<F, Kind2<G, E, (a: A) => B>>) => Kind<F, Kind2<G, E, B>>
+): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
 export function ap<F, G extends URIS2>(
   F: Apply<F>,
   G: Apply2<G>
-): <E, A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
+): <E, A1>(fa: HKT<F, Kind2<G, E, A1>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A1) => B>>) => HKT<F, Kind2<G, E, B>>
 export function ap<F, G extends URIS2, E>(
   F: Apply<F>,
   G: Apply2C<G, E>
-): <A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
+): <A1>(fa: HKT<F, Kind2<G, E, A1>>) => <A2>(fab: HKT<F, Kind2<G, E, (a: A1) => A2>>) => HKT<F, Kind2<G, E, A2>>
 export function ap<F, G extends URIS>(
   F: Apply<F>,
   G: Apply1<G>
-): <A>(fa: HKT<F, Kind<G, A>>) => <B>(fab: HKT<F, Kind<G, (a: A) => B>>) => HKT<F, Kind<G, B>>
+): <A1>(fa: HKT<F, Kind<G, A1>>) => <A2>(fab: HKT<F, Kind<G, (a: A1) => A2>>) => HKT<F, Kind<G, A2>>
 export function ap<F, G>(
   F: Apply<F>,
   G: Apply<G>
-): <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>) => HKT<F, HKT<G, B>>
+): <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>) => HKT<F, HKT<G, A2>>
 export function ap<F, G>(
   F: Apply<F>,
   G: Apply<G>
-): <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>) => HKT<F, HKT<G, B>> {
-  return <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>): HKT<F, HKT<G, B>> =>
+): <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>) => HKT<F, HKT<G, A2>> {
+  return <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>): HKT<F, HKT<G, A2>> =>
     F.ap(
-      F.map(fab, (gab) => (ga: HKT<G, A>) => G.ap(gab, ga)),
+      F.map(fab, (gab) => (ga: HKT<G, A1>) => G.ap(gab, ga)),
       fa
     )
 }

From e2a61ba597456beaf193be4787c4e9082967daa1 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:26:29 +1000
Subject: [PATCH 02/40] feat(Apply/ap): add `Apply<F>` to `Apply3C<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 8f67651eb..2b816de72 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -120,6 +120,12 @@ export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
 ): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+export function ap<F, G extends URIS3, E>(
+  F: Apply<F>,
+  G: Apply3C<G, E>
+): <R, A1>(
+  fa: HKT<F, Kind3<G, R, E, A1>>
+) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A1) => B>>) => HKT<F, Kind3<G, R, E, B>>
 export function ap<F, G extends URIS2>(
   F: Apply<F>,
   G: Apply2<G>

From 9a3ebb4d20cb1d187b23b80df6ae27d10e50aa06 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:26:46 +1000
Subject: [PATCH 03/40] feat(Apply/ap): add `Apply<F>` to `Apply3<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 2b816de72..0932d88bf 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -120,6 +120,12 @@ export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
 ): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+export function ap<F, G extends URIS3>(
+  F: Apply<F>,
+  G: Apply3<G>
+): <R, E, A1>(
+  fa: HKT<F, Kind3<G, R, E, A1>>
+) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A1) => B>>) => HKT<F, Kind3<G, R, E, B>>
 export function ap<F, G extends URIS3, E>(
   F: Apply<F>,
   G: Apply3C<G, E>

From c2b586b978cd22dbc8a5bf5507cc23a91e177925 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:30:26 +1000
Subject: [PATCH 04/40] feat(Apply/ap): add `Apply<F>` to `Apply4<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 0932d88bf..e86bd019d 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -120,6 +120,12 @@ export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
 ): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+export function ap<F, G extends URIS4>(
+  F: Apply<F>,
+  G: Apply4<G>
+): <S, R, E, A1>(
+  fa: HKT<F, Kind4<G, S, R, E, A1>>
+) => <B>(fab: HKT<F, Kind4<G, S, R, E, (a: A1) => B>>) => HKT<F, Kind4<G, S, R, E, B>>
 export function ap<F, G extends URIS3>(
   F: Apply<F>,
   G: Apply3<G>

From 96c96e519aa4576052c2373a13a914817f308bd2 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:36:04 +1000
Subject: [PATCH 05/40] feat(Apply/ap): add `Apply1<F>` to `Apply1<G>` overload

---
 src/Apply.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index e86bd019d..c1e5cacbe 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -120,6 +120,10 @@ export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
 ): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+export function ap<F extends URIS, G extends URIS>(
+  F: Apply1<F>,
+  G: Apply1<G>
+): <A1>(fa: Kind<F, Kind<G, A1>>) => <A2>(fab: Kind<F, Kind<G, (a: A1) => A2>>) => Kind<F, Kind<G, A2>>
 export function ap<F, G extends URIS4>(
   F: Apply<F>,
   G: Apply4<G>

From a5139aeb5807e01efff289f768c5dfbf5f637047 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:39:05 +1000
Subject: [PATCH 06/40] feat(Apply/ap): add `Apply1<F>` to `Apply2<G>` overload

---
 src/Apply.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index c1e5cacbe..9f26f901d 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,10 @@ export function ap<F extends URIS2, G extends URIS2, E>(
 ): <FE, A1>(
   fa: Kind2<F, FE, Kind2<G, E, A1>>
 ) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
+export function ap<F extends URIS, G extends URIS2>(
+  F: Apply1<F>,
+  G: Apply2<G>
+): <E, A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
 export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>

From 9405ecaefe405ea1c90d85c0506ca01a07368bff Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:41:00 +1000
Subject: [PATCH 07/40] feat(Apply/ap): add `Apply1<F>` to `Apply3<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 9f26f901d..d772cfe5b 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS2, E>(
 ): <FE, A1>(
   fa: Kind2<F, FE, Kind2<G, E, A1>>
 ) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
+export function ap<F extends URIS, G extends URIS3>(
+  F: Apply1<F>,
+  G: Apply3<G>
+): <R, E, A1>(
+  fa: Kind<F, Kind3<G, R, E, A1>>
+) => <A2>(fab: Kind<F, Kind3<G, R, E, (a: A1) => A2>>) => Kind<F, Kind3<G, R, E, A2>>
 export function ap<F extends URIS, G extends URIS2>(
   F: Apply1<F>,
   G: Apply2<G>

From 1a3098f7f7679a17c0aba852de22bb9ed03a1a5c Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:42:00 +1000
Subject: [PATCH 08/40] feat(Apply/ap): add `Apply1<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index d772cfe5b..775965c42 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -122,6 +122,12 @@ export function ap<F extends URIS, G extends URIS3>(
 ): <R, E, A1>(
   fa: Kind<F, Kind3<G, R, E, A1>>
 ) => <A2>(fab: Kind<F, Kind3<G, R, E, (a: A1) => A2>>) => Kind<F, Kind3<G, R, E, A2>>
+export function ap<F extends URIS, G extends URIS3, E>(
+  F: Apply1<F>,
+  G: Apply3C<G, E>
+): <R, A1>(
+  fa: Kind<F, Kind3<G, R, E, A1>>
+) => <A2>(fab: Kind<F, Kind3<G, R, E, (a: A1) => A2>>) => Kind<F, Kind3<G, R, E, A2>>
 export function ap<F extends URIS, G extends URIS2>(
   F: Apply1<F>,
   G: Apply2<G>

From fb25871a236b31a9254a59b86bcb7fdfeaa3b8f8 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 09:45:01 +1000
Subject: [PATCH 09/40] feat(Apply/ap): add `Apply1<F>` to `Apply4<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 775965c42..489f3231a 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS2, E>(
 ): <FE, A1>(
   fa: Kind2<F, FE, Kind2<G, E, A1>>
 ) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
+export function ap<F extends URIS, G extends URIS4>(
+  F: Apply1<F>,
+  G: Apply4<G>
+): <S, R, E, A1>(
+  fa: Kind<F, Kind4<G, S, R, E, A1>>
+) => <A2>(fab: Kind<F, Kind4<G, S, R, E, (a: A1) => A2>>) => Kind<F, Kind4<G, S, R, E, A2>>
 export function ap<F extends URIS, G extends URIS3>(
   F: Apply1<F>,
   G: Apply3<G>

From 19e4ff60735fabdd24941a24a1f6ffdf0a6dd93a Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:03:16 +1000
Subject: [PATCH 10/40] feat(Apply/ap): add `Apply2<F>` to `Apply1<G>` overload

---
 src/Apply.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 489f3231a..e7b0113a9 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,10 @@ export function ap<F extends URIS2, G extends URIS2, E>(
 ): <FE, A1>(
   fa: Kind2<F, FE, Kind2<G, E, A1>>
 ) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
+export function ap<F extends URIS2, G extends URIS>(
+  F: Apply2<F>,
+  G: Apply1<G>
+): <E, A1>(fa: Kind2<F, E, Kind<G, A1>>) => <A2>(fab: Kind2<F, E, Kind<G, (a: A1) => A2>>) => Kind2<F, E, Kind<G, A2>>
 export function ap<F extends URIS, G extends URIS4>(
   F: Apply1<F>,
   G: Apply4<G>

From 81b1ec54f08f5003d8dc13b4cf93df42177c4bf2 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:04:56 +1000
Subject: [PATCH 11/40] feat(Apply/ap): add `Apply2<F>` to `Apply2<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index e7b0113a9..db5996fb1 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS2, E>(
 ): <FE, A1>(
   fa: Kind2<F, FE, Kind2<G, E, A1>>
 ) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
+export function ap<F extends URIS2, G extends URIS2>(
+  F: Apply2<F>,
+  G: Apply2<G>
+): <E1, E2, A1>(
+  fa: Kind2<F, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS2, G extends URIS>(
   F: Apply2<F>,
   G: Apply1<G>

From c14228866efc9e13205ef747b5972daff69edf22 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:09:17 +1000
Subject: [PATCH 12/40] refactor(Apply/ap): replace generics `E`/`FE` with
 `E2`/`E1`

---
 src/Apply.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/Apply.ts b/src/Apply.ts
index db5996fb1..a4067bf39 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,18 +110,18 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
-export function ap<F extends URIS2, G extends URIS2, E>(
-  F: Apply2<F>,
-  G: Apply2C<G, E>
-): <FE, A1>(
-  fa: Kind2<F, FE, Kind2<G, E, A1>>
-) => <A2>(fab: Kind2<F, FE, Kind2<G, E, (a: A1) => A2>>) => Kind2<F, FE, Kind2<G, E, A2>>
 export function ap<F extends URIS2, G extends URIS2>(
   F: Apply2<F>,
   G: Apply2<G>
 ): <E1, E2, A1>(
   fa: Kind2<F, E1, Kind2<G, E2, A1>>
 ) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
+export function ap<F extends URIS2, G extends URIS2, E2>(
+  F: Apply2<F>,
+  G: Apply2C<G, E2>
+): <E1, A1>(
+  fa: Kind2<F, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS2, G extends URIS>(
   F: Apply2<F>,
   G: Apply1<G>

From ec265fdf5fa58c51a36f06b3f269190e04ba9e8c Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:12:08 +1000
Subject: [PATCH 13/40] feat(Apply/ap): add `Apply2<F>` to `Apply3<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index a4067bf39..bf8a97196 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS3>(
+  F: Apply2<F>,
+  G: Apply3<G>
+): <R, E1, E2, A1>(
+  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS2>(
   F: Apply2<F>,
   G: Apply2<G>

From 5d7ae0ce0c31d1e7d7217650c9621081ad69e778 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:15:57 +1000
Subject: [PATCH 14/40] feat(Apply/ap): add `Apply2<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index bf8a97196..b5de644ea 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS3>(
 ): <R, E1, E2, A1>(
   fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
 ) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
+export function ap<F extends URIS2, G extends URIS3, E2>(
+  F: Apply2<F>,
+  G: Apply3C<G, E2>
+): <R, E1, A1>(
+  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS2>(
   F: Apply2<F>,
   G: Apply2<G>

From 2afaf987870f3cccd39019e6caec96edd9d95c0d Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:17:30 +1000
Subject: [PATCH 15/40] feat(Apply/ap): add `Apply2<F>` to `Apply4<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index b5de644ea..dee5a6f25 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS4>(
+  F: Apply2<F>,
+  G: Apply4<G>
+): <S, R, E1, E2, A1>(
+  fa: Kind2<F, E1, Kind4<G, S, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind4<G, S, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind4<G, S, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS3>(
   F: Apply2<F>,
   G: Apply3<G>

From 364e999e8b295365f92726c7b5a2efd1ebb31a29 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:19:34 +1000
Subject: [PATCH 16/40] feat(Apply/ap): add `Apply2C<F>` to `Apply1<G>`
 overload

---
 src/Apply.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index dee5a6f25..987d73e27 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,10 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS, E>(
+  F: Apply2C<F, E>,
+  G: Apply1<G>
+): <A1>(fa: Kind2<F, E, Kind<G, A1>>) => <A2>(fab: Kind2<F, E, Kind<G, (a: A1) => A2>>) => Kind2<F, E, Kind<G, A2>>
 export function ap<F extends URIS2, G extends URIS4>(
   F: Apply2<F>,
   G: Apply4<G>

From fce20bab3b5418b14f6d69d563fab612a429125b Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:21:16 +1000
Subject: [PATCH 17/40] feat(Apply/ap): add `Apply2C<F>` to `Apply2<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 987d73e27..3c51c6155 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS2, E1>(
+  F: Apply2C<F, E1>,
+  G: Apply2<G>
+): <E2, A1>(
+  fa: Kind2<F, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS2, G extends URIS, E>(
   F: Apply2C<F, E>,
   G: Apply1<G>

From b822abc0e4dee0a85e97096eba7096dda8502368 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:24:26 +1000
Subject: [PATCH 18/40] feat(Apply/ap): add `Apply2C<F>` to `Apply2C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 3c51c6155..e0f29cade 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS2, E1>(
 ): <E2, A1>(
   fa: Kind2<F, E1, Kind2<G, E2, A1>>
 ) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
+export function ap<F extends URIS2, G extends URIS2, E1, E2>(
+  F: Apply2C<F, E1>,
+  G: Apply2C<G, E2>
+): <A1>(
+  fa: Kind2<F, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS2, G extends URIS, E>(
   F: Apply2C<F, E>,
   G: Apply1<G>

From 2c206bb70bb5fc4a888338a1040dddc5141a45f2 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:26:33 +1000
Subject: [PATCH 19/40] feat(Apply/ap): add `Apply2C<F>` to `Apply3<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index e0f29cade..fd04d1f8d 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS3, E1>(
+  F: Apply2C<F, E1>,
+  G: Apply3<G>
+): <R, E2, A1>(
+  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS2, E1>(
   F: Apply2C<F, E1>,
   G: Apply2<G>

From 0da9bf48e94ff5a18b974e5fa7d5a50dfc3e3ae3 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:28:02 +1000
Subject: [PATCH 20/40] feat(Apply/ap): add `Apply2C<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index fd04d1f8d..f47a579ab 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS2, G extends URIS3, E1>(
 ): <R, E2, A1>(
   fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
 ) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
+export function ap<F extends URIS2, G extends URIS3, E1, E2>(
+  F: Apply2C<F, E1>,
+  G: Apply3C<G, E2>
+): <R, A1>(
+  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS2, E1>(
   F: Apply2C<F, E1>,
   G: Apply2<G>

From 1e7662d57ae9710c163aeb061190def975e8c9ef Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:29:18 +1000
Subject: [PATCH 21/40] feat(Apply/ap): add `Apply2C<F>` to `Apply4<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index f47a579ab..7ceeb5421 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS2, G extends URIS4, E1>(
+  F: Apply2C<F, E1>,
+  G: Apply4<G>
+): <S, R, E2, A1>(
+  fa: Kind2<F, E1, Kind4<G, S, R, E2, A1>>
+) => <A2>(fab: Kind2<F, E1, Kind4<G, S, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind4<G, S, R, E2, A2>>
 export function ap<F extends URIS2, G extends URIS3, E1>(
   F: Apply2C<F, E1>,
   G: Apply3<G>

From 9edada8239cf665a7b71be76a78fceba98e5f773 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:32:25 +1000
Subject: [PATCH 22/40] feat(Apply/ap): add `Apply3<F>` to `Apply1<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 7ceeb5421..760cb21e1 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS3, G extends URIS>(
+  F: Apply3<F>,
+  G: Apply1<G>
+): <R, E, A1>(
+  fa: Kind3<F, R, E, Kind<G, A1>>
+) => <A2>(fab: Kind3<F, R, E, Kind<G, (a: A1) => A2>>) => Kind3<F, R, E, Kind<G, A2>>
 export function ap<F extends URIS2, G extends URIS4, E1>(
   F: Apply2C<F, E1>,
   G: Apply4<G>

From 13a40a1a0a8602cec732cf944be2e9949b70b197 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:33:34 +1000
Subject: [PATCH 23/40] feat(Apply/ap): add `Apply3<F>` to `Apply2<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 760cb21e1..96bf748d2 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS3, G extends URIS2>(
+  F: Apply3<F>,
+  G: Apply2<G>
+): <R, E1, E2, A1>(
+  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS3, G extends URIS>(
   F: Apply3<F>,
   G: Apply1<G>

From 57c62fd790dd65296bcec583f641685ce2bb97d8 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:34:13 +1000
Subject: [PATCH 24/40] feat(Apply/ap): add `Apply3<F>` to `Apply2C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 96bf748d2..15bab919d 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS3, G extends URIS2>(
 ): <R, E1, E2, A1>(
   fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
 ) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
+export function ap<F extends URIS3, G extends URIS2, E2>(
+  F: Apply3<F>,
+  G: Apply2C<G, E2>
+): <R, E1, A1>(
+  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS3, G extends URIS>(
   F: Apply3<F>,
   G: Apply1<G>

From 9289609ac1abcf947845576945e0c8e78bfde439 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:36:01 +1000
Subject: [PATCH 25/40] feat(Apply/ap): add `Apply3<F>` to `Apply3<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 15bab919d..22803fe0f 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS3, G extends URIS3>(
+  F: Apply3<F>,
+  G: Apply3<G>
+): <R1, R2, E1, E2, A1>(
+  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS2>(
   F: Apply3<F>,
   G: Apply2<G>

From 4f40a07adad01406d4c89e49cbbb03a9a6aa9a6a Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:37:14 +1000
Subject: [PATCH 26/40] feat(Apply/ap): add `Apply3<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 22803fe0f..c3d44b4fe 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS3, G extends URIS3>(
 ): <R1, R2, E1, E2, A1>(
   fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
 ) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
+export function ap<F extends URIS3, G extends URIS3, E2>(
+  F: Apply3<F>,
+  G: Apply3C<G, E2>
+): <R1, R2, E1, A1>(
+  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS2>(
   F: Apply3<F>,
   G: Apply2<G>

From dee55447dcd98bc9e21b4ddb64acc8d746d9df7b Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 10:38:02 +1000
Subject: [PATCH 27/40] feat(Apply/ap): add `Apply3<F>` to `Apply4<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index c3d44b4fe..329cb4017 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS3, G extends URIS4>(
+  F: Apply3<F>,
+  G: Apply4<G>
+): <S, R1, R2, E1, E2, A1>(
+  fa: Kind3<F, R1, E1, Kind4<G, S, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind4<G, S, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind4<G, S, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS3>(
   F: Apply3<F>,
   G: Apply3<G>

From b4e964720e078db2593f1730ba57175de9a8f65e Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:02:00 +1000
Subject: [PATCH 28/40] feat(Apply/ap): add `Apply4<F>` to `Apply1<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 329cb4017..58107f3eb 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS4, G extends URIS>(
+  F: Apply4<F>,
+  G: Apply1<G>
+): <S, R, E, A1>(
+  fa: Kind4<F, S, R, E, Kind<G, A1>>
+) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
 export function ap<F extends URIS3, G extends URIS4>(
   F: Apply3<F>,
   G: Apply4<G>

From 3ca3bc6b42e386188e810b8bc9bc16d5d675a9d0 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:02:14 +1000
Subject: [PATCH 29/40] feat(Apply/ap): add `Apply4<F>` to `Apply2<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 58107f3eb..e99bf1c60 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS4, G extends URIS2>(
+  F: Apply4<F>,
+  G: Apply2<G>
+): <S, R, E1, E2, A1>(
+  fa: Kind4<F, S, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind4<F, S, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind4<F, S, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS4, G extends URIS>(
   F: Apply4<F>,
   G: Apply1<G>

From 215958d351763e41897c1c66fdb0855d9806f7a1 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:02:28 +1000
Subject: [PATCH 30/40] feat(Apply/ap): add `Apply4<F>` to `Apply2C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index e99bf1c60..901977ebc 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS4, G extends URIS2>(
 ): <S, R, E1, E2, A1>(
   fa: Kind4<F, S, R, E1, Kind2<G, E2, A1>>
 ) => <A2>(fab: Kind4<F, S, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind4<F, S, R, E1, Kind2<G, E2, A2>>
+export function ap<F extends URIS4, G extends URIS2, E2>(
+  F: Apply4<F>,
+  G: Apply2C<G, E2>
+): <S, R, E1, A1>(
+  fa: Kind4<F, S, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind4<F, S, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind4<F, S, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS4, G extends URIS>(
   F: Apply4<F>,
   G: Apply1<G>

From 8e613911f8617bac8ad9d1356ca8f908d72892c5 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:02:45 +1000
Subject: [PATCH 31/40] feat(Apply/ap): add `Apply4<F>` to `Apply3<G>` overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 901977ebc..d05d2e170 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,12 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS4, G extends URIS3>(
+  F: Apply4<F>,
+  G: Apply3<G>
+): <S, R1, R2, E1, E2, A1>(
+  fa: Kind4<F, S, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind4<F, S, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind4<F, S, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS4, G extends URIS2>(
   F: Apply4<F>,
   G: Apply2<G>

From dce9d5f4099ee6869405a6d55e4f8d01b298efff Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:02:54 +1000
Subject: [PATCH 32/40] feat(Apply/ap): add `Apply4<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index d05d2e170..e31941bf6 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -116,6 +116,12 @@ export function ap<F extends URIS4, G extends URIS3>(
 ): <S, R1, R2, E1, E2, A1>(
   fa: Kind4<F, S, R1, E1, Kind3<G, R2, E2, A1>>
 ) => <A2>(fab: Kind4<F, S, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind4<F, S, R1, E1, Kind3<G, R2, E2, A2>>
+export function ap<F extends URIS4, G extends URIS3, E2>(
+  F: Apply4<F>,
+  G: Apply3C<G, E2>
+): <S, R1, R2, E1, A1>(
+  fa: Kind4<F, S, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind4<F, S, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind4<F, S, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS4, G extends URIS2>(
   F: Apply4<F>,
   G: Apply2<G>

From edffe35592ab6ae4f713b9849ffd1d37a1eda68f Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:03:03 +1000
Subject: [PATCH 33/40] feat(Apply/ap): add `Apply4<F>` to `Apply4<G>` overload

---
 src/Apply.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index e31941bf6..cfa77c15c 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -110,6 +110,14 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
  * @category combinators
  * @since 2.10.0
  */
+export function ap<F extends URIS4, G extends URIS4>(
+  F: Apply4<F>,
+  G: Apply4<G>
+): <S1, S2, R1, R2, E1, E2, A1>(
+  fa: Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, A1>>
+) => <A2>(
+  fab: Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, (a: A1) => A2>>
+) => Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, A2>>
 export function ap<F extends URIS4, G extends URIS3>(
   F: Apply4<F>,
   G: Apply3<G>

From cee58eae8732ca165f43e03070dfefadebde4544 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:09:24 +1000
Subject: [PATCH 34/40] feat(Apply/ap): add `Apply3C<F>` to `Apply1<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index cfa77c15c..0f20a1048 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -148,6 +148,12 @@ export function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A1>(
   fa: Kind4<F, S, R, E, Kind<G, A1>>
 ) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
+export function ap<F extends URIS3, G extends URIS, E>(
+  F: Apply3C<F, E>,
+  G: Apply1<G>
+): <R, A1>(
+  fa: Kind3<F, R, E, Kind<G, A1>>
+) => <A2>(fab: Kind3<F, R, E, Kind<G, (a: A1) => A2>>) => Kind3<F, R, E, Kind<G, A2>>
 export function ap<F extends URIS3, G extends URIS4>(
   F: Apply3<F>,
   G: Apply4<G>

From 84cd63f131fc91dfd509998f10b6747430a2d9e7 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:09:39 +1000
Subject: [PATCH 35/40] feat(Apply/ap): add `Apply3C<F>` to `Apply2<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 0f20a1048..574495adb 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -148,6 +148,12 @@ export function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A1>(
   fa: Kind4<F, S, R, E, Kind<G, A1>>
 ) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
+export function ap<F extends URIS3, G extends URIS2, E1>(
+  F: Apply3C<F, E1>,
+  G: Apply2<G>
+): <R, E2, A1>(
+  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS3, G extends URIS, E>(
   F: Apply3C<F, E>,
   G: Apply1<G>

From f9d33049c6b796cbe058d3a0729e10a2260b4cfe Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:09:53 +1000
Subject: [PATCH 36/40] feat(Apply/ap): add `Apply3C<F>` to `Apply2C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 574495adb..6beb0202d 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -154,6 +154,12 @@ export function ap<F extends URIS3, G extends URIS2, E1>(
 ): <R, E2, A1>(
   fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
 ) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
+export function ap<F extends URIS3, G extends URIS2, E1, E2>(
+  F: Apply3C<F, E1>,
+  G: Apply2C<G, E2>
+): <R, A1>(
+  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
+) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
 export function ap<F extends URIS3, G extends URIS, E>(
   F: Apply3C<F, E>,
   G: Apply1<G>

From d4d41f9327cb42690ab1758ca2b42029ec9005ec Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:10:11 +1000
Subject: [PATCH 37/40] feat(Apply/ap): add `Apply3C<F>` to `Apply3<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 6beb0202d..507557852 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -148,6 +148,12 @@ export function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A1>(
   fa: Kind4<F, S, R, E, Kind<G, A1>>
 ) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
+export function ap<F extends URIS3, G extends URIS3, E1>(
+  F: Apply3C<F, E1>,
+  G: Apply3<G>
+): <R1, R2, E2, A1>(
+  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS2, E1>(
   F: Apply3C<F, E1>,
   G: Apply2<G>

From 70917bda69746f88148e69d323abb5f0093f1514 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:10:28 +1000
Subject: [PATCH 38/40] feat(Apply/ap): add `Apply3C<F>` to `Apply3C<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 507557852..16f37f43a 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -154,6 +154,12 @@ export function ap<F extends URIS3, G extends URIS3, E1>(
 ): <R1, R2, E2, A1>(
   fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
 ) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
+export function ap<F extends URIS3, G extends URIS3, E1, E2>(
+  F: Apply3C<F, E1>,
+  G: Apply3C<G, E2>
+): <R1, R2, E1, A1>(
+  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS2, E1>(
   F: Apply3C<F, E1>,
   G: Apply2<G>

From 5e4f4aadeec7ddbd5adaadd119aa56f5dd3fe8bd Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 12 Jun 2022 11:10:35 +1000
Subject: [PATCH 39/40] feat(Apply/ap): add `Apply3C<F>` to `Apply4<G>`
 overload

---
 src/Apply.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Apply.ts b/src/Apply.ts
index 16f37f43a..ae6baf445 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -148,6 +148,12 @@ export function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A1>(
   fa: Kind4<F, S, R, E, Kind<G, A1>>
 ) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
+export function ap<F extends URIS3, G extends URIS4, E1>(
+  F: Apply3C<F, E1>,
+  G: Apply4<G>
+): <S, R1, R2, E2, A1>(
+  fa: Kind3<F, R1, E1, Kind4<G, S, R2, E2, A1>>
+) => <A2>(fab: Kind3<F, R1, E1, Kind4<G, S, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind4<G, S, R2, E2, A2>>
 export function ap<F extends URIS3, G extends URIS3, E1>(
   F: Apply3C<F, E1>,
   G: Apply3<G>

From 950f4c89aebdd476b8ec4710d6f077747501f772 Mon Sep 17 00:00:00 2001
From: Wayne Van Son <waynevanson@gmail.com>
Date: Sun, 14 Aug 2022 17:37:07 +1000
Subject: [PATCH 40/40] refactor(apply): normailise generic names

---
 src/Apply.ts | 300 +++++++++++++++++++++++++--------------------------
 1 file changed, 148 insertions(+), 152 deletions(-)

diff --git a/src/Apply.ts b/src/Apply.ts
index ae6baf445..461c4850e 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -113,252 +113,248 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
 export function ap<F extends URIS4, G extends URIS4>(
   F: Apply4<F>,
   G: Apply4<G>
-): <S1, S2, R1, R2, E1, E2, A1>(
-  fa: Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, A1>>
-) => <A2>(
-  fab: Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, (a: A1) => A2>>
-) => Kind4<F, S1, R1, E1, Kind4<G, S2, R2, E2, A2>>
+): <FS, GS, FR, GR, FE, GE, A>(
+  fa: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, A>>
+) => <B>(fab: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, (a: A) => B>>) => Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, B>>
 export function ap<F extends URIS4, G extends URIS3>(
   F: Apply4<F>,
   G: Apply3<G>
-): <S, R1, R2, E1, E2, A1>(
-  fa: Kind4<F, S, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind4<F, S, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind4<F, S, R1, E1, Kind3<G, R2, E2, A2>>
-export function ap<F extends URIS4, G extends URIS3, E2>(
+): <S, FR, GR, FE, GE, A>(
+  fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
+export function ap<F extends URIS4, G extends URIS3, GE>(
   F: Apply4<F>,
-  G: Apply3C<G, E2>
-): <S, R1, R2, E1, A1>(
-  fa: Kind4<F, S, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind4<F, S, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind4<F, S, R1, E1, Kind3<G, R2, E2, A2>>
+  G: Apply3C<G, GE>
+): <S, FR, GR, FE, A>(
+  fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS4, G extends URIS2>(
   F: Apply4<F>,
   G: Apply2<G>
-): <S, R, E1, E2, A1>(
-  fa: Kind4<F, S, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind4<F, S, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind4<F, S, R, E1, Kind2<G, E2, A2>>
-export function ap<F extends URIS4, G extends URIS2, E2>(
+): <S, R, FE, GE, A>(
+  fa: Kind4<F, S, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind4<F, S, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind4<F, S, R, FE, Kind2<G, GE, B>>
+export function ap<F extends URIS4, G extends URIS2, GE>(
   F: Apply4<F>,
-  G: Apply2C<G, E2>
-): <S, R, E1, A1>(
-  fa: Kind4<F, S, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind4<F, S, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind4<F, S, R, E1, Kind2<G, E2, A2>>
+  G: Apply2C<G, GE>
+): <S, R, FE, A>(
+  fa: Kind4<F, S, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind4<F, S, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind4<F, S, R, FE, Kind2<G, GE, B>>
 export function ap<F extends URIS4, G extends URIS>(
   F: Apply4<F>,
   G: Apply1<G>
-): <S, R, E, A1>(
-  fa: Kind4<F, S, R, E, Kind<G, A1>>
-) => <A2>(fab: Kind4<F, S, R, E, Kind<G, (a: A1) => A2>>) => Kind4<F, S, R, E, Kind<G, A2>>
-export function ap<F extends URIS3, G extends URIS4, E1>(
-  F: Apply3C<F, E1>,
+): <S, R, E, A>(
+  fa: Kind4<F, S, R, E, Kind<G, A>>
+) => <B>(fab: Kind4<F, S, R, E, Kind<G, (a: A) => B>>) => Kind4<F, S, R, E, Kind<G, B>>
+export function ap<F extends URIS3, G extends URIS4, FE>(
+  F: Apply3C<F, FE>,
   G: Apply4<G>
-): <S, R1, R2, E2, A1>(
-  fa: Kind3<F, R1, E1, Kind4<G, S, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind4<G, S, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind4<G, S, R2, E2, A2>>
-export function ap<F extends URIS3, G extends URIS3, E1>(
-  F: Apply3C<F, E1>,
+): <S, FR, GR, GE, A>(
+  fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
+export function ap<F extends URIS3, G extends URIS3, FE>(
+  F: Apply3C<F, FE>,
   G: Apply3<G>
-): <R1, R2, E2, A1>(
-  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
-export function ap<F extends URIS3, G extends URIS3, E1, E2>(
-  F: Apply3C<F, E1>,
-  G: Apply3C<G, E2>
-): <R1, R2, E1, A1>(
-  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
-export function ap<F extends URIS3, G extends URIS2, E1>(
-  F: Apply3C<F, E1>,
+): <FR, GR, GE, A>(
+  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
+export function ap<F extends URIS3, G extends URIS3, FE, GE>(
+  F: Apply3C<F, FE>,
+  G: Apply3C<G, GE>
+): <FR, GR, FE, A>(
+  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
+export function ap<F extends URIS3, G extends URIS2, FE>(
+  F: Apply3C<F, FE>,
   G: Apply2<G>
-): <R, E2, A1>(
-  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
-export function ap<F extends URIS3, G extends URIS2, E1, E2>(
-  F: Apply3C<F, E1>,
-  G: Apply2C<G, E2>
-): <R, A1>(
-  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
+): <R, GE, A>(
+  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
+export function ap<F extends URIS3, G extends URIS2, FE, GE>(
+  F: Apply3C<F, FE>,
+  G: Apply2C<G, GE>
+): <R, A>(
+  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
 export function ap<F extends URIS3, G extends URIS, E>(
   F: Apply3C<F, E>,
   G: Apply1<G>
-): <R, A1>(
-  fa: Kind3<F, R, E, Kind<G, A1>>
-) => <A2>(fab: Kind3<F, R, E, Kind<G, (a: A1) => A2>>) => Kind3<F, R, E, Kind<G, A2>>
+): <R, A>(
+  fa: Kind3<F, R, E, Kind<G, A>>
+) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
 export function ap<F extends URIS3, G extends URIS4>(
   F: Apply3<F>,
   G: Apply4<G>
-): <S, R1, R2, E1, E2, A1>(
-  fa: Kind3<F, R1, E1, Kind4<G, S, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind4<G, S, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind4<G, S, R2, E2, A2>>
+): <S, FR, GR, FE, GE, A>(
+  fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
 export function ap<F extends URIS3, G extends URIS3>(
   F: Apply3<F>,
   G: Apply3<G>
-): <R1, R2, E1, E2, A1>(
-  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
-export function ap<F extends URIS3, G extends URIS3, E2>(
+): <FR, GR, FE, GE, A>(
+  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
+export function ap<F extends URIS3, G extends URIS3, GE>(
   F: Apply3<F>,
-  G: Apply3C<G, E2>
-): <R1, R2, E1, A1>(
-  fa: Kind3<F, R1, E1, Kind3<G, R2, E2, A1>>
-) => <A2>(fab: Kind3<F, R1, E1, Kind3<G, R2, E2, (a: A1) => A2>>) => Kind3<F, R1, E1, Kind3<G, R2, E2, A2>>
+  G: Apply3C<G, GE>
+): <FR, GR, FE, A>(
+  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
+) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS3, G extends URIS2>(
   F: Apply3<F>,
   G: Apply2<G>
-): <R, E1, E2, A1>(
-  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
-export function ap<F extends URIS3, G extends URIS2, E2>(
+): <R, FE, GE, A>(
+  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
+export function ap<F extends URIS3, G extends URIS2, GE>(
   F: Apply3<F>,
-  G: Apply2C<G, E2>
-): <R, E1, A1>(
-  fa: Kind3<F, R, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind3<F, R, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind3<F, R, E1, Kind2<G, E2, A2>>
+  G: Apply2C<G, GE>
+): <R, FE, A>(
+  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
 export function ap<F extends URIS3, G extends URIS>(
   F: Apply3<F>,
   G: Apply1<G>
-): <R, E, A1>(
-  fa: Kind3<F, R, E, Kind<G, A1>>
-) => <A2>(fab: Kind3<F, R, E, Kind<G, (a: A1) => A2>>) => Kind3<F, R, E, Kind<G, A2>>
-export function ap<F extends URIS2, G extends URIS4, E1>(
-  F: Apply2C<F, E1>,
+): <R, E, A>(
+  fa: Kind3<F, R, E, Kind<G, A>>
+) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
+export function ap<F extends URIS2, G extends URIS4, FE>(
+  F: Apply2C<F, FE>,
   G: Apply4<G>
-): <S, R, E2, A1>(
-  fa: Kind2<F, E1, Kind4<G, S, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind4<G, S, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind4<G, S, R, E2, A2>>
-export function ap<F extends URIS2, G extends URIS3, E1>(
-  F: Apply2C<F, E1>,
+): <S, R, GE, A>(
+  fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
+export function ap<F extends URIS2, G extends URIS3, FE>(
+  F: Apply2C<F, FE>,
   G: Apply3<G>
-): <R, E2, A1>(
-  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
-export function ap<F extends URIS2, G extends URIS3, E1, E2>(
-  F: Apply2C<F, E1>,
-  G: Apply3C<G, E2>
-): <R, A1>(
-  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
-export function ap<F extends URIS2, G extends URIS2, E1>(
-  F: Apply2C<F, E1>,
+): <R, GE, A>(
+  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
+export function ap<F extends URIS2, G extends URIS3, FE, GE>(
+  F: Apply2C<F, FE>,
+  G: Apply3C<G, GE>
+): <R, A>(
+  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
+export function ap<F extends URIS2, G extends URIS2, FE>(
+  F: Apply2C<F, FE>,
   G: Apply2<G>
-): <E2, A1>(
-  fa: Kind2<F, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
-export function ap<F extends URIS2, G extends URIS2, E1, E2>(
-  F: Apply2C<F, E1>,
-  G: Apply2C<G, E2>
-): <A1>(
-  fa: Kind2<F, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
+): <GE, A>(
+  fa: Kind2<F, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
+export function ap<F extends URIS2, G extends URIS2, FE, GE>(
+  F: Apply2C<F, FE>,
+  G: Apply2C<G, GE>
+): <A>(
+  fa: Kind2<F, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
 export function ap<F extends URIS2, G extends URIS, E>(
   F: Apply2C<F, E>,
   G: Apply1<G>
-): <A1>(fa: Kind2<F, E, Kind<G, A1>>) => <A2>(fab: Kind2<F, E, Kind<G, (a: A1) => A2>>) => Kind2<F, E, Kind<G, A2>>
+): <A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
 export function ap<F extends URIS2, G extends URIS4>(
   F: Apply2<F>,
   G: Apply4<G>
-): <S, R, E1, E2, A1>(
-  fa: Kind2<F, E1, Kind4<G, S, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind4<G, S, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind4<G, S, R, E2, A2>>
+): <S, R, FE, GE, A>(
+  fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
 export function ap<F extends URIS2, G extends URIS3>(
   F: Apply2<F>,
   G: Apply3<G>
-): <R, E1, E2, A1>(
-  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
-export function ap<F extends URIS2, G extends URIS3, E2>(
+): <R, FE, GE, A>(
+  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
+export function ap<F extends URIS2, G extends URIS3, GE>(
   F: Apply2<F>,
-  G: Apply3C<G, E2>
-): <R, E1, A1>(
-  fa: Kind2<F, E1, Kind3<G, R, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind3<G, R, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind3<G, R, E2, A2>>
+  G: Apply3C<G, GE>
+): <R, FE, A>(
+  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
 export function ap<F extends URIS2, G extends URIS2>(
   F: Apply2<F>,
   G: Apply2<G>
-): <E1, E2, A1>(
-  fa: Kind2<F, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
-export function ap<F extends URIS2, G extends URIS2, E2>(
+): <FE, GE, A>(
+  fa: Kind2<F, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
+export function ap<F extends URIS2, G extends URIS2, GE>(
   F: Apply2<F>,
-  G: Apply2C<G, E2>
-): <E1, A1>(
-  fa: Kind2<F, E1, Kind2<G, E2, A1>>
-) => <A2>(fab: Kind2<F, E1, Kind2<G, E2, (a: A1) => A2>>) => Kind2<F, E1, Kind2<G, E2, A2>>
+  G: Apply2C<G, GE>
+): <FE, A>(
+  fa: Kind2<F, FE, Kind2<G, GE, A>>
+) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
 export function ap<F extends URIS2, G extends URIS>(
   F: Apply2<F>,
   G: Apply1<G>
-): <E, A1>(fa: Kind2<F, E, Kind<G, A1>>) => <A2>(fab: Kind2<F, E, Kind<G, (a: A1) => A2>>) => Kind2<F, E, Kind<G, A2>>
+): <E, A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
 export function ap<F extends URIS, G extends URIS4>(
   F: Apply1<F>,
   G: Apply4<G>
-): <S, R, E, A1>(
-  fa: Kind<F, Kind4<G, S, R, E, A1>>
-) => <A2>(fab: Kind<F, Kind4<G, S, R, E, (a: A1) => A2>>) => Kind<F, Kind4<G, S, R, E, A2>>
+): <S, R, E, A>(
+  fa: Kind<F, Kind4<G, S, R, E, A>>
+) => <B>(fab: Kind<F, Kind4<G, S, R, E, (a: A) => B>>) => Kind<F, Kind4<G, S, R, E, B>>
 export function ap<F extends URIS, G extends URIS3>(
   F: Apply1<F>,
   G: Apply3<G>
-): <R, E, A1>(
-  fa: Kind<F, Kind3<G, R, E, A1>>
-) => <A2>(fab: Kind<F, Kind3<G, R, E, (a: A1) => A2>>) => Kind<F, Kind3<G, R, E, A2>>
+): <R, E, A>(
+  fa: Kind<F, Kind3<G, R, E, A>>
+) => <B>(fab: Kind<F, Kind3<G, R, E, (a: A) => B>>) => Kind<F, Kind3<G, R, E, B>>
 export function ap<F extends URIS, G extends URIS3, E>(
   F: Apply1<F>,
   G: Apply3C<G, E>
-): <R, A1>(
-  fa: Kind<F, Kind3<G, R, E, A1>>
-) => <A2>(fab: Kind<F, Kind3<G, R, E, (a: A1) => A2>>) => Kind<F, Kind3<G, R, E, A2>>
+): <R, A>(
+  fa: Kind<F, Kind3<G, R, E, A>>
+) => <B>(fab: Kind<F, Kind3<G, R, E, (a: A) => B>>) => Kind<F, Kind3<G, R, E, B>>
 export function ap<F extends URIS, G extends URIS2>(
   F: Apply1<F>,
   G: Apply2<G>
-): <E, A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+): <E, A>(fa: Kind<F, Kind2<G, E, A>>) => <B>(fab: Kind<F, Kind2<G, E, (a: A) => B>>) => Kind<F, Kind2<G, E, B>>
 export function ap<F extends URIS, G extends URIS2, E>(
   F: Apply1<F>,
   G: Apply2C<G, E>
-): <A1>(fa: Kind<F, Kind2<G, E, A1>>) => <A2>(fab: Kind<F, Kind2<G, E, (a: A1) => A2>>) => Kind<F, Kind2<G, E, A2>>
+): <A>(fa: Kind<F, Kind2<G, E, A>>) => <B>(fab: Kind<F, Kind2<G, E, (a: A) => B>>) => Kind<F, Kind2<G, E, B>>
 export function ap<F extends URIS, G extends URIS>(
   F: Apply1<F>,
   G: Apply1<G>
-): <A1>(fa: Kind<F, Kind<G, A1>>) => <A2>(fab: Kind<F, Kind<G, (a: A1) => A2>>) => Kind<F, Kind<G, A2>>
+): <A>(fa: Kind<F, Kind<G, A>>) => <B>(fab: Kind<F, Kind<G, (a: A) => B>>) => Kind<F, Kind<G, B>>
 export function ap<F, G extends URIS4>(
   F: Apply<F>,
   G: Apply4<G>
-): <S, R, E, A1>(
-  fa: HKT<F, Kind4<G, S, R, E, A1>>
-) => <B>(fab: HKT<F, Kind4<G, S, R, E, (a: A1) => B>>) => HKT<F, Kind4<G, S, R, E, B>>
+): <S, R, E, A>(
+  fa: HKT<F, Kind4<G, S, R, E, A>>
+) => <B>(fab: HKT<F, Kind4<G, S, R, E, (a: A) => B>>) => HKT<F, Kind4<G, S, R, E, B>>
 export function ap<F, G extends URIS3>(
   F: Apply<F>,
   G: Apply3<G>
-): <R, E, A1>(
-  fa: HKT<F, Kind3<G, R, E, A1>>
-) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A1) => B>>) => HKT<F, Kind3<G, R, E, B>>
+): <R, E, A>(
+  fa: HKT<F, Kind3<G, R, E, A>>
+) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A) => B>>) => HKT<F, Kind3<G, R, E, B>>
 export function ap<F, G extends URIS3, E>(
   F: Apply<F>,
   G: Apply3C<G, E>
-): <R, A1>(
-  fa: HKT<F, Kind3<G, R, E, A1>>
-) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A1) => B>>) => HKT<F, Kind3<G, R, E, B>>
+): <R, A>(fa: HKT<F, Kind3<G, R, E, A>>) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A) => B>>) => HKT<F, Kind3<G, R, E, B>>
 export function ap<F, G extends URIS2>(
   F: Apply<F>,
   G: Apply2<G>
-): <E, A1>(fa: HKT<F, Kind2<G, E, A1>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A1) => B>>) => HKT<F, Kind2<G, E, B>>
+): <E, A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
 export function ap<F, G extends URIS2, E>(
   F: Apply<F>,
   G: Apply2C<G, E>
-): <A1>(fa: HKT<F, Kind2<G, E, A1>>) => <A2>(fab: HKT<F, Kind2<G, E, (a: A1) => A2>>) => HKT<F, Kind2<G, E, A2>>
+): <A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
 export function ap<F, G extends URIS>(
   F: Apply<F>,
   G: Apply1<G>
-): <A1>(fa: HKT<F, Kind<G, A1>>) => <A2>(fab: HKT<F, Kind<G, (a: A1) => A2>>) => HKT<F, Kind<G, A2>>
+): <A>(fa: HKT<F, Kind<G, A>>) => <B>(fab: HKT<F, Kind<G, (a: A) => B>>) => HKT<F, Kind<G, B>>
 export function ap<F, G>(
   F: Apply<F>,
   G: Apply<G>
-): <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>) => HKT<F, HKT<G, A2>>
+): <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>) => HKT<F, HKT<G, B>>
 export function ap<F, G>(
   F: Apply<F>,
   G: Apply<G>
-): <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>) => HKT<F, HKT<G, A2>> {
-  return <A1>(fa: HKT<F, HKT<G, A1>>) => <A2>(fab: HKT<F, HKT<G, (a: A1) => A2>>): HKT<F, HKT<G, A2>> =>
+): <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>) => HKT<F, HKT<G, B>> {
+  return <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>): HKT<F, HKT<G, B>> =>
     F.ap(
-      F.map(fab, (gab) => (ga: HKT<G, A1>) => G.ap(gab, ga)),
+      F.map(fab, (gab) => (ga: HKT<G, A>) => G.ap(gab, ga)),
       fa
     )
 }