@fncts/base 0.0.12 → 0.0.15

package/_src/typeclass/Apply.ts

@@ -7,32 +7,34 @@ import { tuple } from "@fncts/base/data/function";
 /**
  * @tsplus type fncts.Apply
  */
-export interface Apply<F extends HKT> extends Semimonoidal<F>, Functor<F> {
-  zipWith<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(
-    self: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>, Functor<F, FC> {
+  zipWith: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(
+    self: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
     that: HKT.Kind<
       F,
-      HKT.Intro<"K", K1, K2>,
-      HKT.Intro<"Q", Q1, Q2>,
-      HKT.Intro<"W", W1, W2>,
-      HKT.Intro<"X", X1, X2>,
-      HKT.Intro<"I", I1, I2>,
-      HKT.Intro<"S", S1, S2>,
-      HKT.Intro<"R", R1, R2>,
-      HKT.Intro<"E", E1, E2>,
+      FC,
+      HKT.Intro<F, "K", K1, K2>,
+      HKT.Intro<F, "Q", Q1, Q2>,
+      HKT.Intro<F, "W", W1, W2>,
+      HKT.Intro<F, "X", X1, X2>,
+      HKT.Intro<F, "I", I1, I2>,
+      HKT.Intro<F, "S", S1, S2>,
+      HKT.Intro<F, "R", R1, R2>,
+      HKT.Intro<F, "E", E1, E2>,
       B
     >,
     f: (a: A, b: B) => D,
-  ): HKT.Kind<
+  ) => HKT.Kind<
     F,
-    HKT.Mix<"K", [K1, K2]>,
-    HKT.Mix<"Q", [Q1, Q2]>,
-    HKT.Mix<"W", [W1, W2]>,
-    HKT.Mix<"X", [X1, X2]>,
-    HKT.Mix<"I", [I1, I2]>,
-    HKT.Mix<"S", [S1, S2]>,
-    HKT.Mix<"R", [R1, R2]>,
-    HKT.Mix<"E", [E1, E2]>,
+    FC,
+    HKT.Mix<F, "K", [K1, K2]>,
+    HKT.Mix<F, "Q", [Q1, Q2]>,
+    HKT.Mix<F, "W", [W1, W2]>,
+    HKT.Mix<F, "X", [X1, X2]>,
+    HKT.Mix<F, "I", [I1, I2]>,
+    HKT.Mix<F, "S", [S1, S2]>,
+    HKT.Mix<F, "R", [R1, R2]>,
+    HKT.Mix<F, "E", [E1, E2]>,
     D
   >;
 }
@@ -45,220 +47,179 @@ export interface ApplyOps {}
 export const Apply: ApplyOps = {};
 
 /**
- * @tsplus fluent fncts.Kind zipWith
+ * @tsplus static fncts.ApplyOps ap
  */
-export function zipWith<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, D>(
-  self: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
-  that: HKT.Kind<
-    F,
-    HKT.Intro<"K", K1, K2>,
-    HKT.Intro<"Q", Q1, Q2>,
-    HKT.Intro<"W", W1, W2>,
-    HKT.Intro<"X", X1, X2>,
-    HKT.Intro<"I", I1, I2>,
-    HKT.Intro<"S", S1, S2>,
-    HKT.Intro<"R", R1, R2>,
-    HKT.Intro<"E", E1, E2>,
-    B
-  >,
-  f: (a: A, b: B) => D,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
-  F,
-  HKT.Mix<"K", [K1, K2]>,
-  HKT.Mix<"Q", [Q1, Q2]>,
-  HKT.Mix<"W", [W1, W2]>,
-  HKT.Mix<"X", [X1, X2]>,
-  HKT.Mix<"I", [I1, I2]>,
-  HKT.Mix<"S", [S1, S2]>,
-  HKT.Mix<"R", [R1, R2]>,
-  HKT.Mix<"E", [E1, E2]>,
-  D
-> {
-  return F.zipWith(self, that, f);
-}
-
-/**
- * @tsplus fluent fncts.Kind ap
- */
-export function ap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fab: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>,
+export function ap<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  fab: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, (a: A) => B>,
   fa: HKT.Kind<
     F,
-    HKT.Intro<"K", K1, K2>,
-    HKT.Intro<"Q", Q1, Q2>,
-    HKT.Intro<"W", W1, W2>,
-    HKT.Intro<"X", X1, X2>,
-    HKT.Intro<"I", I1, I2>,
-    HKT.Intro<"S", S1, S2>,
-    HKT.Intro<"R", R1, R2>,
-    HKT.Intro<"E", E1, E2>,
+    FC,
+    HKT.Intro<F, "K", K1, K2>,
+    HKT.Intro<F, "Q", Q1, Q2>,
+    HKT.Intro<F, "W", W1, W2>,
+    HKT.Intro<F, "X", X1, X2>,
+    HKT.Intro<F, "I", I1, I2>,
+    HKT.Intro<F, "S", S1, S2>,
+    HKT.Intro<F, "R", R1, R2>,
+    HKT.Intro<F, "E", E1, E2>,
     A
   >,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  HKT.Mix<"K", [K1, K2]>,
-  HKT.Mix<"Q", [Q1, Q2]>,
-  HKT.Mix<"W", [W1, W2]>,
-  HKT.Mix<"X", [X1, X2]>,
-  HKT.Mix<"I", [I1, I2]>,
-  HKT.Mix<"S", [S1, S2]>,
-  HKT.Mix<"R", [R1, R2]>,
-  HKT.Mix<"E", [E1, E2]>,
+  FC,
+  HKT.Mix<F, "K", [K1, K2]>,
+  HKT.Mix<F, "Q", [Q1, Q2]>,
+  HKT.Mix<F, "W", [W1, W2]>,
+  HKT.Mix<F, "X", [X1, X2]>,
+  HKT.Mix<F, "I", [I1, I2]>,
+  HKT.Mix<F, "S", [S1, S2]>,
+  HKT.Mix<F, "R", [R1, R2]>,
+  HKT.Mix<F, "E", [E1, E2]>,
   B
 > {
-  return fab.zipWith(fa, (f, a) => f(a));
+  return (fab, fa) => F.zipWith(fab, fa, (f, a) => f(a));
 }
 
 /**
- * @tsplus fluent fncts.Kind apFirst
+ * @tsplus static fncts.ApplyOps apFirst
  */
-export function apFirst<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+export function apFirst<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   fb: HKT.Kind<
     F,
-    HKT.Intro<"K", K1, K2>,
-    HKT.Intro<"Q", Q1, Q2>,
-    HKT.Intro<"W", W1, W2>,
-    HKT.Intro<"X", X1, X2>,
-    HKT.Intro<"I", I1, I2>,
-    HKT.Intro<"S", S1, S2>,
-    HKT.Intro<"R", R1, R2>,
-    HKT.Intro<"E", E1, E2>,
+    FC,
+    HKT.Intro<F, "K", K1, K2>,
+    HKT.Intro<F, "Q", Q1, Q2>,
+    HKT.Intro<F, "W", W1, W2>,
+    HKT.Intro<F, "X", X1, X2>,
+    HKT.Intro<F, "I", I1, I2>,
+    HKT.Intro<F, "S", S1, S2>,
+    HKT.Intro<F, "R", R1, R2>,
+    HKT.Intro<F, "E", E1, E2>,
     B
   >,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  HKT.Mix<"K", [K1, K2]>,
-  HKT.Mix<"Q", [Q1, Q2]>,
-  HKT.Mix<"W", [W1, W2]>,
-  HKT.Mix<"X", [X1, X2]>,
-  HKT.Mix<"I", [I1, I2]>,
-  HKT.Mix<"S", [S1, S2]>,
-  HKT.Mix<"R", [R1, R2]>,
-  HKT.Mix<"E", [E1, E2]>,
+  FC,
+  HKT.Mix<F, "K", [K1, K2]>,
+  HKT.Mix<F, "Q", [Q1, Q2]>,
+  HKT.Mix<F, "W", [W1, W2]>,
+  HKT.Mix<F, "X", [X1, X2]>,
+  HKT.Mix<F, "I", [I1, I2]>,
+  HKT.Mix<F, "S", [S1, S2]>,
+  HKT.Mix<F, "R", [R1, R2]>,
+  HKT.Mix<F, "E", [E1, E2]>,
   A
 > {
-  return fa.zipWith(fb, (a, _) => a);
+  return (fa, fb) => F.zipWith(fa, fb, (a, _) => a);
 }
 
 /**
- * @tsplus fluent fncts.Kind apSecond
+ * @tsplus static fncts.ApplyOps apSecond
  */
-export function apSecond<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-  fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+export function apSecond<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   fb: HKT.Kind<
     F,
-    HKT.Intro<"K", K1, K2>,
-    HKT.Intro<"Q", Q1, Q2>,
-    HKT.Intro<"W", W1, W2>,
-    HKT.Intro<"X", X1, X2>,
-    HKT.Intro<"I", I1, I2>,
-    HKT.Intro<"S", S1, S2>,
-    HKT.Intro<"R", R1, R2>,
-    HKT.Intro<"E", E1, E2>,
+    FC,
+    HKT.Intro<F, "K", K1, K2>,
+    HKT.Intro<F, "Q", Q1, Q2>,
+    HKT.Intro<F, "W", W1, W2>,
+    HKT.Intro<F, "X", X1, X2>,
+    HKT.Intro<F, "I", I1, I2>,
+    HKT.Intro<F, "S", S1, S2>,
+    HKT.Intro<F, "R", R1, R2>,
+    HKT.Intro<F, "E", E1, E2>,
     B
   >,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  HKT.Mix<"K", [K1, K2]>,
-  HKT.Mix<"Q", [Q1, Q2]>,
-  HKT.Mix<"W", [W1, W2]>,
-  HKT.Mix<"X", [X1, X2]>,
-  HKT.Mix<"I", [I1, I2]>,
-  HKT.Mix<"S", [S1, S2]>,
-  HKT.Mix<"R", [R1, R2]>,
-  HKT.Mix<"E", [E1, E2]>,
+  FC,
+  HKT.Mix<F, "K", [K1, K2]>,
+  HKT.Mix<F, "Q", [Q1, Q2]>,
+  HKT.Mix<F, "W", [W1, W2]>,
+  HKT.Mix<F, "X", [X1, X2]>,
+  HKT.Mix<F, "I", [I1, I2]>,
+  HKT.Mix<F, "S", [S1, S2]>,
+  HKT.Mix<F, "R", [R1, R2]>,
+  HKT.Mix<F, "E", [E1, E2]>,
   B
 > {
-  return fa.zipWith(fb, (_, b) => b);
+  return (fa, fb) => F.zipWith(fa, fb, (_, b) => b);
 }
 
-export function apS<
-  F extends HKT,
-  K1,
-  Q1,
-  W1,
-  X1,
-  I1,
-  S1,
-  R1,
-  E1,
-  A,
-  BN extends string,
-  K2,
-  Q2,
-  W2,
-  X2,
-  I2,
-  S2,
-  R2,
-  E2,
-  B,
->(
-  fa: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+export function apS<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <K1, Q1, W1, X1, I1, S1, R1, E1, A, BN extends string, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
+  fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   name: Exclude<BN, keyof A>,
   fb: HKT.Kind<
     F,
-    HKT.Intro<"K", K1, K2>,
-    HKT.Intro<"Q", Q1, Q2>,
-    HKT.Intro<"W", W1, W2>,
-    HKT.Intro<"X", X1, X2>,
-    HKT.Intro<"I", I1, I2>,
-    HKT.Intro<"S", S1, S2>,
-    HKT.Intro<"R", R1, R2>,
-    HKT.Intro<"E", E1, E2>,
+    FC,
+    HKT.Intro<F, "K", K1, K2>,
+    HKT.Intro<F, "Q", Q1, Q2>,
+    HKT.Intro<F, "W", W1, W2>,
+    HKT.Intro<F, "X", X1, X2>,
+    HKT.Intro<F, "I", I1, I2>,
+    HKT.Intro<F, "S", S1, S2>,
+    HKT.Intro<F, "R", R1, R2>,
+    HKT.Intro<F, "E", E1, E2>,
     B
   >,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  HKT.Mix<"K", [K1, K2]>,
-  HKT.Mix<"Q", [Q1, Q2]>,
-  HKT.Mix<"W", [W1, W2]>,
-  HKT.Mix<"X", [X1, X2]>,
-  HKT.Mix<"I", [I1, I2]>,
-  HKT.Mix<"S", [S1, S2]>,
-  HKT.Mix<"R", [R1, R2]>,
-  HKT.Mix<"E", [E1, E2]>,
+  FC,
+  HKT.Mix<F, "K", [K1, K2]>,
+  HKT.Mix<F, "Q", [Q1, Q2]>,
+  HKT.Mix<F, "W", [W1, W2]>,
+  HKT.Mix<F, "X", [X1, X2]>,
+  HKT.Mix<F, "I", [I1, I2]>,
+  HKT.Mix<F, "S", [S1, S2]>,
+  HKT.Mix<F, "R", [R1, R2]>,
+  HKT.Mix<F, "E", [E1, E2]>,
   { [K in keyof A | BN]: K extends keyof A ? A[K] : B }
 > {
-  return fa.zipWith(fb, (a, b) => ({ ...a, [name]: b } as { [K in keyof A | BN]: K extends keyof A ? A[K] : B }));
+  return (fa, name, fb) => F.zipWith(fa, fb, (a, b) => unsafeCoerce({ ...a, [name]: b }));
 }
 
 /**
  * @tsplus static fncts.ApplyOps sequenceS
  */
-export function sequenceS<
-  F extends HKT,
+export function sequenceS<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <
   KS extends Readonly<
     Record<
       string,
       HKT.Kind<
         F,
-        HKT.Intro<"K", K, any>,
-        HKT.Intro<"Q", Q, any>,
-        HKT.Intro<"W", W, any>,
-        HKT.Intro<"Q", Q, any>,
-        HKT.Intro<"I", I, any>,
-        HKT.Intro<"S", S, any>,
-        HKT.Intro<"R", R, any>,
-        HKT.Intro<"E", E, any>,
+        FC,
+        HKT.Intro<F, "K", K, any>,
+        HKT.Intro<F, "Q", Q, any>,
+        HKT.Intro<F, "W", W, any>,
+        HKT.Intro<F, "Q", Q, any>,
+        HKT.Intro<F, "I", I, any>,
+        HKT.Intro<F, "S", S, any>,
+        HKT.Intro<F, "R", R, any>,
+        HKT.Intro<F, "E", E, any>,
         A
       >
     >
   >,
   A,
-  K = HKT.Low<"K">,
-  Q = HKT.Low<"Q">,
-  W = HKT.Low<"W">,
-  I = HKT.Low<"I">,
-  S = HKT.Low<"S">,
-  R = HKT.Low<"R">,
-  E = HKT.Low<"E">,
+  K = HKT.Low<F, "K">,
+  Q = HKT.Low<F, "Q">,
+  W = HKT.Low<F, "W">,
+  I = HKT.Low<F, "I">,
+  S = HKT.Low<F, "S">,
+  R = HKT.Low<F, "R">,
+  E = HKT.Low<F, "E">,
 >(
   r: Object.EnforceNonEmpty<KS> &
     Readonly<
@@ -266,104 +227,112 @@ export function sequenceS<
         string,
         HKT.Kind<
           F,
-          HKT.Intro<"K", K, any>,
-          HKT.Intro<"Q", Q, any>,
-          HKT.Intro<"W", W, any>,
-          HKT.Intro<"Q", Q, any>,
-          HKT.Intro<"I", I, any>,
-          HKT.Intro<"S", S, any>,
-          HKT.Intro<"R", R, any>,
-          HKT.Intro<"E", E, any>,
+          FC,
+          HKT.Intro<F, "K", K, any>,
+          HKT.Intro<F, "Q", Q, any>,
+          HKT.Intro<F, "W", W, any>,
+          HKT.Intro<F, "Q", Q, any>,
+          HKT.Intro<F, "I", I, any>,
+          HKT.Intro<F, "S", S, any>,
+          HKT.Intro<F, "R", R, any>,
+          HKT.Intro<F, "E", E, any>,
           A
         >
       >
     >,
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  InferMixStruct<F, "K", K, KS>,
-  InferMixStruct<F, "Q", Q, KS>,
-  InferMixStruct<F, "W", W, KS>,
-  InferMixStruct<F, "Q", Q, KS>,
-  InferMixStruct<F, "I", I, KS>,
-  InferMixStruct<F, "S", S, KS>,
-  InferMixStruct<F, "R", R, KS>,
-  InferMixStruct<F, "E", E, KS>,
+  FC,
+  InferMixStruct<F, FC, "K", K, KS>,
+  InferMixStruct<F, FC, "Q", Q, KS>,
+  InferMixStruct<F, FC, "W", W, KS>,
+  InferMixStruct<F, FC, "Q", Q, KS>,
+  InferMixStruct<F, FC, "I", I, KS>,
+  InferMixStruct<F, FC, "S", S, KS>,
+  InferMixStruct<F, FC, "R", R, KS>,
+  InferMixStruct<F, FC, "E", E, KS>,
   {
-    [K in keyof KS]: HKT.Infer<F, "A", KS[K]>;
+    [K in keyof KS]: HKT.Infer<F, FC, "A", KS[K]>;
   }
 > {
-  const keys = globalThis.Object.keys(r);
-  const len  = keys.length;
-  const f    = getRecordConstructor(keys);
-  let fr     = F.map(r[keys[0]!]! as HKT.ErasedKind<F>, f);
-  for (let i = 1; i < len; i++) {
-    fr = fr.ap(r[keys[i]!]!, F);
-  }
-  return fr;
+  return (r) => {
+    const keys = globalThis.Object.keys(r);
+    const len  = keys.length;
+    const f    = getRecordConstructor(keys);
+    let fr     = F.map(r[keys[0]!]!, f);
+    for (let i = 1; i < len; i++) {
+      fr = Apply.ap(F)(fr, unsafeCoerce(r[keys[i]!]!));
+    }
+    return unsafeCoerce(fr);
+  };
 }
 
-export function sequenceT<
-  F extends HKT,
+export function sequenceT<F extends HKT, FC = HKT.None>(
+  F: Apply<F, FC>,
+): <
   KT extends readonly [
     HKT.Kind<
       F,
-      HKT.Intro<"K", K, any>,
-      HKT.Intro<"Q", Q, any>,
-      HKT.Intro<"W", W, any>,
-      HKT.Intro<"Q", Q, any>,
-      HKT.Intro<"I", I, any>,
-      HKT.Intro<"S", S, any>,
-      HKT.Intro<"R", R, any>,
-      HKT.Intro<"E", E, any>,
+      FC,
+      HKT.Intro<F, "K", K, any>,
+      HKT.Intro<F, "Q", Q, any>,
+      HKT.Intro<F, "W", W, any>,
+      HKT.Intro<F, "Q", Q, any>,
+      HKT.Intro<F, "I", I, any>,
+      HKT.Intro<F, "S", S, any>,
+      HKT.Intro<F, "R", R, any>,
+      HKT.Intro<F, "E", E, any>,
       unknown
     >,
     ...ReadonlyArray<
       HKT.Kind<
         F,
-        HKT.Intro<"K", K, any>,
-        HKT.Intro<"Q", Q, any>,
-        HKT.Intro<"W", W, any>,
-        HKT.Intro<"Q", Q, any>,
-        HKT.Intro<"I", I, any>,
-        HKT.Intro<"S", S, any>,
-        HKT.Intro<"R", R, any>,
-        HKT.Intro<"E", E, any>,
+        FC,
+        HKT.Intro<F, "K", K, any>,
+        HKT.Intro<F, "Q", Q, any>,
+        HKT.Intro<F, "W", W, any>,
+        HKT.Intro<F, "Q", Q, any>,
+        HKT.Intro<F, "I", I, any>,
+        HKT.Intro<F, "S", S, any>,
+        HKT.Intro<F, "R", R, any>,
+        HKT.Intro<F, "E", E, any>,
         unknown
       >
     >,
   ],
-  K = HKT.Low<"K">,
-  Q = HKT.Low<"Q">,
-  W = HKT.Low<"W">,
-  I = HKT.Low<"I">,
-  S = HKT.Low<"S">,
-  R = HKT.Low<"R">,
-  E = HKT.Low<"E">,
+  K = HKT.Low<F, "K">,
+  Q = HKT.Low<F, "Q">,
+  W = HKT.Low<F, "W">,
+  I = HKT.Low<F, "I">,
+  S = HKT.Low<F, "S">,
+  R = HKT.Low<F, "R">,
+  E = HKT.Low<F, "E">,
 >(
   t: [...KT],
-  /** @tsplus auto */ F: Apply<F>,
-): HKT.Kind<
+) => HKT.Kind<
   F,
-  InferMixTuple<F, "K", K, KT>,
-  InferMixTuple<F, "Q", Q, KT>,
-  InferMixTuple<F, "W", W, KT>,
-  InferMixTuple<F, "Q", Q, KT>,
-  InferMixTuple<F, "I", I, KT>,
-  InferMixTuple<F, "S", S, KT>,
-  InferMixTuple<F, "R", R, KT>,
-  InferMixTuple<F, "E", E, KT>,
+  FC,
+  InferMixTuple<F, FC, "K", K, KT>,
+  InferMixTuple<F, FC, "Q", Q, KT>,
+  InferMixTuple<F, FC, "W", W, KT>,
+  InferMixTuple<F, FC, "Q", Q, KT>,
+  InferMixTuple<F, FC, "I", I, KT>,
+  InferMixTuple<F, FC, "S", S, KT>,
+  InferMixTuple<F, FC, "R", R, KT>,
+  InferMixTuple<F, FC, "E", E, KT>,
   {
-    [K in keyof KT]: HKT.Infer<F, "A", KT[K]>;
+    [K in keyof KT]: HKT.Infer<F, FC, "A", KT[K]>;
   }
 > {
-  const len = t.length;
-  const f   = getTupleConstructor(len);
-  let fas   = F.map(t[0] as HKT.ErasedKind<F>, f);
-  for (let i = 1; i < len; i++) {
-    fas = fas.ap(t[i]!, F);
-  }
-  return fas;
+  return (t) => {
+    const len = t.length;
+    const f   = getTupleConstructor(len);
+    let fas   = F.map(t[0], f);
+    for (let i = 1; i < len; i++) {
+      fas = Apply.ap(F)(fas, unsafeCoerce(t[i]!));
+    }
+    return unsafeCoerce(fas);
+  };
 }
 
 /*
@@ -428,17 +397,19 @@ function getRecordConstructor(keys: ReadonlyArray<string>) {
 /**
  * @internal
  */
-type InferMixStruct<F extends HKT, P extends HKT.ParamName, T, KS> = HKT.MixStruct<
+type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<
+  F,
   P,
   T,
-  { [K in keyof KS]: HKT.Infer<F, P, KS[K]> }
+  { [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]> }
 >;
 
 /**
  * @internal
  */
-type InferMixTuple<F extends HKT, P extends HKT.ParamName, T, KT> = HKT.MixStruct<
+type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixStruct<
+  F,
   P,
   T,
-  { [K in keyof KT & number]: HKT.Infer<F, P, KT[K]> }
+  { [K in keyof KT & number]: HKT.Infer<F, FC, P, KT[K]> }
 >;