@fncts/base 0.0.1 → 0.0.4

package/_src/optics/Traversal/definition.ts

@@ -7,12 +7,19 @@ import { PSetter } from "@fncts/base/optics/Setter";
  * @tsplus type fncts.optics.PTraversal
  */
 export interface PTraversal<S, T, A, B> extends PSetter<S, T, A, B>, Fold<S, A> {
-  readonly modifyA_: modifyA_<S, T, A, B>;
-  readonly modifyA: modifyA<S, T, A, B>;
+  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+    s: S,
+    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
+    /** @tsplus auto */ F: Applicative<F>,
+  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 
 export interface PTraversalMin<S, T, A, B> {
-  readonly modifyA_: modifyA_<S, T, A, B>;
+  modifyA<F extends HKT, K, Q, W, X, I, _S, R, E>(
+    s: S,
+    f: (a: A) => HKT.Kind<F, K, Q, W, X, I, _S, R, E, B>,
+    /** @tsplus auto */ F: Applicative<F>,
+  ): HKT.Kind<F, K, Q, W, X, I, _S, R, E, T>;
 }
 
 /**
@@ -27,17 +34,21 @@ export const PTraversal: PTraversalOps = {};
  */
 export function mkPTraversal<S, T, A, B>(F: PTraversalMin<S, T, A, B>): PTraversal<S, T, A, B> {
   return {
-    modifyA_: F.modifyA_,
-    modifyA: (A) => (f) => (s) => F.modifyA_(A)(s, f),
-    ...PSetter({
-      modify_: (s, f) => F.modifyA_(Identity.Applicative)(s, f),
-      set_: (s, b) => F.modifyA_(Identity.Applicative)(s, () => b),
+    modifyA: F.modifyA,
+    ...PSetter<S, T, A, B>({
+      modify_: (s, f) =>
+        F.modifyA(
+          s,
+          f.compose((b) => Identity.get(b)),
+          Identity.Applicative,
+        ).getIdentity,
+      set_: (s, b) => F.modifyA(s, () => Identity.get(b), Identity.Applicative).getIdentity,
     }),
-    ...Fold({
+    ...Fold<S, A>({
       foldMap_:
         <M>(M: Monoid<M>) =>
         (s: S, f: (a: A) => M) =>
-          F.modifyA_(Const.getApplicative(M))(s, (a) => Const(f(a))),
+          F.modifyA(s, (a) => Const(f(a)), Const.getApplicative(M)).getConst,
     }),
   };
 }
@@ -58,16 +69,3 @@ export interface TraversalOps extends PTraversalOps {}
 export function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A> {
   return PTraversal(F);
 }
-
-export interface modifyA_<S, T, A, B> {
-  <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(
-    s: S,
-    f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>,
-  ) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}
-
-export interface modifyA<S, T, A, B> {
-  <F extends HKT, C = HKT.None>(F: Applicative<F, C>): <K, Q, W, X, I, _S, R, E>(
-    f: (a: A) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, B>,
-  ) => (s: S) => HKT.Kind<F, C, K, Q, W, X, I, _S, R, E, T>;
-}

package/_src/typeclass/Align.ts

@@ -1,28 +1,14 @@
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-import type { SemialignMin } from "@fncts/base/typeclass/Semialign";
-
-import { Semialign } from "@fncts/base/typeclass/Semialign";
+import type { Nil } from "@fncts/base/typeclass/Nil";
+import type { Semialign } from "@fncts/base/typeclass/Semialign";
 
 /**
  * @tsplus type fncts.Align
  */
-export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, Nil<F, FC> {}
+export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {}
 
 /**
  * @tsplus type fncts.AlignOps
  */
 export interface AlignOps {}
 
-export const Align: AlignOps = {};
-
-export type AlignMin<F extends HKT, FC = HKT.None> = SemialignMin<F, FC> & NilMin<F, FC>;
-
-/**
- * @tsplus static fncts.AlignOps __call
- */
-export function mkAlign<F extends HKT, FC = HKT.None>(F: AlignMin<F, FC>): Align<F, FC> {
-  return HKT.instance<Align<F, FC>>({
-    ...Semialign(F),
-    nil: F.nil,
-  });
-}
+export const Align: AlignOps = {};

package/_src/typeclass/Alt.ts

@@ -1,13 +1,37 @@
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-
-import { Functor } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 
 /**
  * @tsplus type fncts.Alt
  */
-export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-  readonly alt_: alt_<F, FC>;
-  readonly alt: alt<F, FC>;
+export interface Alt<F extends HKT> extends Functor<F> {
+  alt<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
+    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+    that: Lazy<
+      HKT.Kind<
+        F,
+        HKT.Intro<"K", K, K1>,
+        HKT.Intro<"Q", Q, Q1>,
+        HKT.Intro<"W", W, W1>,
+        HKT.Intro<"X", X, X1>,
+        HKT.Intro<"I", I, I1>,
+        HKT.Intro<"S", S, S1>,
+        HKT.Intro<"R", R, R1>,
+        HKT.Intro<"E", E, E1>,
+        HKT.Intro<"A", A, B>
+      >
+    >,
+  ): HKT.Kind<
+    F,
+    HKT.Mix<"K", [K, K1]>,
+    HKT.Mix<"Q", [Q, Q1]>,
+    HKT.Mix<"W", [W, W1]>,
+    HKT.Mix<"X", [X, X1]>,
+    HKT.Mix<"I", [I, I1]>,
+    HKT.Mix<"S", [S, S1]>,
+    HKT.Mix<"R", [R, R1]>,
+    HKT.Mix<"E", [E, E1]>,
+    HKT.Mix<"A", [A, B]>
+  >;
 }
 
 /**
@@ -17,89 +41,34 @@ export interface AltOps {}
 
 export const Alt: AltOps = {};
 
-export type AltMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-  readonly alt_: alt_<F, FC>;
-};
-
-/**
- * @tsplus static fncts.AltOps __call
- */
-export function mkAlt<F extends HKT, C = HKT.None>(F: AltMin<F, C>): Alt<F, C>;
-export function mkAlt<F>(F: AltMin<HKT.F<F>>): Alt<HKT.F<F>> {
-  return HKT.instance<Alt<HKT.F<F>>>({
-    ...Functor(F),
-    alt_: F.alt_,
-    alt: (that) => (fa) => F.alt_(fa, that),
-  });
-}
-
-export interface alt<F extends HKT, C = HKT.None> {
-  <K1, Q1, W1, X1, I1, S1, R1, E1, B>(that: () => HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <
-    K,
-    Q,
-    W,
-    X,
-    I,
-    S,
-    R,
-    E,
-    A,
-  >(
-    fa: HKT.Kind<
+export function alt<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
+  self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  that: Lazy<
+    HKT.Kind<
       F,
-      C,
-      HKT.Intro<F, "K", K1, K>,
-      HKT.Intro<F, "Q", Q1, Q>,
-      HKT.Intro<F, "W", W1, W>,
-      HKT.Intro<F, "X", X1, X>,
-      HKT.Intro<F, "I", I1, I>,
-      HKT.Intro<F, "S", S1, S>,
-      HKT.Intro<F, "R", R1, R>,
-      HKT.Intro<F, "E", E1, E>,
-      HKT.Intro<F, "A", B, A>
-    >,
-  ) => HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K1, K]>,
-    HKT.Mix<F, "Q", [Q1, Q]>,
-    HKT.Mix<F, "W", [W1, W]>,
-    HKT.Mix<F, "X", [X1, X]>,
-    HKT.Mix<F, "I", [I1, I]>,
-    HKT.Mix<F, "S", [S1, S]>,
-    HKT.Mix<F, "R", [R1, R]>,
-    HKT.Mix<F, "E", [E1, E]>,
-    HKT.Mix<F, "A", [B, A]>
-  >;
-}
-
-export interface alt_<F extends HKT, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, B>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-    that: () => HKT.Kind<
-      F,
-      C,
-      HKT.Intro<F, "K", K, K1>,
-      HKT.Intro<F, "Q", Q, Q1>,
-      HKT.Intro<F, "W", W, W1>,
-      HKT.Intro<F, "X", X, X1>,
-      HKT.Intro<F, "I", I, I1>,
-      HKT.Intro<F, "S", S, S1>,
-      HKT.Intro<F, "R", R, R1>,
-      HKT.Intro<F, "E", E, E1>,
-      HKT.Intro<F, "A", A, B>
-    >,
-  ): HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K, K1]>,
-    HKT.Mix<F, "Q", [Q, Q1]>,
-    HKT.Mix<F, "W", [W, W1]>,
-    HKT.Mix<F, "X", [X, X1]>,
-    HKT.Mix<F, "I", [I, I1]>,
-    HKT.Mix<F, "S", [S, S1]>,
-    HKT.Mix<F, "R", [R, R1]>,
-    HKT.Mix<F, "E", [E, E1]>,
-    HKT.Mix<F, "A", [A, B]>
-  >;
+      HKT.Intro<"K", K, K1>,
+      HKT.Intro<"Q", Q, Q1>,
+      HKT.Intro<"W", W, W1>,
+      HKT.Intro<"X", X, X1>,
+      HKT.Intro<"I", I, I1>,
+      HKT.Intro<"S", S, S1>,
+      HKT.Intro<"R", R, R1>,
+      HKT.Intro<"E", E, E1>,
+      HKT.Intro<"A", A, B>
+    >
+  >,
+  /** @tsplus auto */ F: Alt<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K, K1]>,
+  HKT.Mix<"Q", [Q, Q1]>,
+  HKT.Mix<"W", [W, W1]>,
+  HKT.Mix<"X", [X, X1]>,
+  HKT.Mix<"I", [I, I1]>,
+  HKT.Mix<"S", [S, S1]>,
+  HKT.Mix<"R", [R, R1]>,
+  HKT.Mix<"E", [E, E1]>,
+  HKT.Mix<"A", [A, B]>
+> {
+  return F.alt(self, that);
 }

package/_src/typeclass/Alternative.ts

@@ -1,14 +1,11 @@
-import type { AltMin } from "@fncts/base/typeclass/Alt";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Nil, NilMin } from "@fncts/base/typeclass/Nil";
-
-import { Alt } from "@fncts/base/typeclass/Alt";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Alt } from "@fncts/base/typeclass/Alt";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Nil } from "@fncts/base/typeclass/Nil";
 
 /**
  * @tsplus type fncts.Alternative
  */
-export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, Nil<F, FC>, Alt<F, FC> {}
+export interface Alternative<F extends HKT> extends Applicative<F>, Nil<F>, Alt<F> {}
 
 /**
  * @tsplus type fncts.AlternativeOps
@@ -16,16 +13,3 @@ export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F
 export interface AlternativeOps {}
 
 export const Alternative: AlternativeOps = {};
-
-export type AlternativeMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & NilMin<F, FC> & AltMin<F, FC>;
-
-/**
- * @tsplus static fncts.AlternativeOps __call
- */
-export function mkAlternative<F extends HKT, C = HKT.None>(F: AlternativeMin<F, C>): Alternative<F, C> {
-  return HKT.instance<Alternative<F, C>>({
-    ...Applicative(F),
-    ...Alt(F),
-    nil: F.nil,
-  });
-}

package/_src/typeclass/Applicative.ts

@@ -1,10 +1,7 @@
-import type { ApplyMin } from "@fncts/base/typeclass/Apply";
-import type { PointedMin } from "@fncts/base/typeclass/Pointed";
+import type { Apply } from "@fncts/base/typeclass/Apply";
+import type { Pointed } from "@fncts/base/typeclass/Pointed";
 
-import { Apply } from "@fncts/base/typeclass/Apply";
-import { Pointed } from "@fncts/base/typeclass/Pointed";
-
-export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>, Pointed<F, FC> {}
+export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {}
 
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -12,20 +9,3 @@ export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>,
 export interface ApplicativeOps {}
 
 export const Applicative: ApplicativeOps = {};
-
-export type ApplicativeMin<F extends HKT, FC = HKT.None> = ApplyMin<F, FC> & PointedMin<F, FC>;
-
-/**
- * @tsplus static fncts.ApplicativeOps __call
- */
-export function mkApplicative<F extends HKT, FC = HKT.None>(F: ApplicativeMin<F, FC>): Applicative<F, FC> {
-  return HKT.instance<Applicative<F, FC>>({
-    ...Pointed(F),
-    ...Apply(F),
-  });
-}
-
-export type CompatibleApplicative<F extends HKT, C, A> = Applicative<F, C> &
-  ([A] extends [HKT.Kind<F, any, any, any, any, any, any, any, any, any, any>]
-    ? unknown
-    : ["invalid Applicative instance for", A]);

package/_src/typeclass/ApplicativeExcept.ts

@@ -1,226 +1,127 @@
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Fail, FailMin } from "@fncts/base/typeclass/Fail";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Fail } from "@fncts/base/typeclass/Fail";
 
 import { identity } from "@fncts/base/data/function";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
 
 /**
  * @tsplus type fncts.ApplicativeExcept
  */
-export interface ApplicativeExcept<F extends HKT.CovariantE, C = HKT.None> extends Applicative<F, C>, Fail<F, C> {
-  readonly catchAll_: CatchAllFn_<F, C>;
-  readonly catchAll: CatchAllFn<F, C>;
-  readonly catchJust_: CatchJustFn_<F, C>;
-  readonly catchJust: CatchJustFn<F, C>;
-  readonly either: EitherFn<F, C>;
-}
-
-/**
- * @tsplus type fncts.ApplicativeExceptOps
- */
-export interface ApplicativeExceptOps {}
-
-export const ApplicativeExcept: ApplicativeExceptOps = {};
-
-export type ApplicativeExceptMin<F extends HKT.CovariantE, C = HKT.None> = ApplicativeMin<F, C> &
-  FailMin<F, C> & {
-    readonly catchAll_: CatchAllFn_<F, C>;
-  };
-
-/**
- * @tsplus static fncts.ApplicativeExceptOps __call
- */
-export function mkApplicativeExcept<F extends HKT.CovariantE, C = HKT.None>(
-  F: ApplicativeExceptMin<F, C>,
-): ApplicativeExcept<F, C>;
-export function mkApplicativeExcept<F>(F: ApplicativeExceptMin<HKT.FCoE<F>>): ApplicativeExcept<HKT.FCoE<F>> {
-  const ApplicativeF = Applicative(F);
-  const catchJust_   = catchJustF_(F);
-  return HKT.instance<ApplicativeExcept<HKT.FCoE<F>>>({
-    ...ApplicativeF,
-    catchAll_: F.catchAll_,
-    catchAll: (f) => (fa) => F.catchAll_(fa, f),
-    catchJust_,
-    catchJust: (f) => (fa) => catchJust_(fa, f),
-    either: eitherF(F),
-    fail: F.fail,
-  });
-}
-
-export interface CatchAllFn_<F extends HKT.CovariantE, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
+export interface ApplicativeExcept<F extends HKT> extends Applicative<F>, Fail<F> {
+  catchAll<K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
+    fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
     f: (
-      e: HKT.OrFix<C, "E", E>,
+      e: E,
     ) => HKT.Kind<
       F,
-      C,
-      HKT.Intro<F, "K", K, K1>,
-      HKT.Intro<F, "Q", Q, Q1>,
-      HKT.Intro<F, "W", W, W1>,
-      HKT.Intro<F, "X", X, X1>,
-      HKT.Intro<F, "I", I, I1>,
-      HKT.Intro<F, "S", S, S1>,
-      HKT.Intro<F, "R", R, R1>,
-      HKT.Intro<F, "E", E, E1>,
+      HKT.Intro<"K", K, K1>,
+      HKT.Intro<"Q", Q, Q1>,
+      HKT.Intro<"W", W, W1>,
+      HKT.Intro<"X", X, X1>,
+      HKT.Intro<"I", I, I1>,
+      HKT.Intro<"S", S, S1>,
+      HKT.Intro<"R", R, R1>,
+      HKT.Intro<"E", E, E1>,
       A1
     >,
   ): HKT.Kind<
     F,
-    C,
-    HKT.Mix<F, "K", [K, K1]>,
-    HKT.Mix<F, "Q", [Q, Q1]>,
-    HKT.Mix<F, "W", [W, W1]>,
-    HKT.Mix<F, "X", [X, X1]>,
-    HKT.Mix<F, "I", [I, I1]>,
-    HKT.Mix<F, "S", [S, S1]>,
-    HKT.Mix<F, "R", [R, R1]>,
+    HKT.Mix<"K", [K, K1]>,
+    HKT.Mix<"Q", [Q, Q1]>,
+    HKT.Mix<"W", [W, W1]>,
+    HKT.Mix<"X", [X, X1]>,
+    HKT.Mix<"I", [I, I1]>,
+    HKT.Mix<"S", [S, S1]>,
+    HKT.Mix<"R", [R, R1]>,
     E1,
     A | A1
   >;
 }
 
-export interface CatchAllFn<F extends HKT.CovariantE, C = HKT.None> {
-  <E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    f: (e: HKT.OrFix<C, "E", E>) => HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A1>,
-  ): <K, Q, W, X, I, S, R, A>(
-    fa: HKT.Kind<
-      F,
-      C,
-      HKT.Intro<F, "K", K1, K>,
-      HKT.Intro<F, "Q", Q1, Q>,
-      HKT.Intro<F, "W", W1, W>,
-      HKT.Intro<F, "X", X1, X>,
-      HKT.Intro<F, "I", I1, I>,
-      HKT.Intro<F, "S", S1, S>,
-      HKT.Intro<F, "R", R1, R>,
-      HKT.Intro<F, "E", E1, E>,
-      A
-    >,
-  ) => HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K1, K]>,
-    HKT.Mix<F, "Q", [Q1, Q]>,
-    HKT.Mix<F, "W", [W1, W]>,
-    HKT.Mix<F, "X", [X1, X]>,
-    HKT.Mix<F, "I", [I1, I]>,
-    HKT.Mix<F, "S", [S1, S]>,
-    HKT.Mix<F, "R", [R1, R]>,
-    E1,
-    A | A1
-  >;
-}
+/**
+ * @tsplus type fncts.ApplicativeExceptOps
+ */
+export interface ApplicativeExceptOps {}
 
-export interface CatchJustFn_<F extends HKT.CovariantE, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-    f: (
-      e: HKT.OrFix<C, "E", E>,
-    ) => Maybe<
-      HKT.Kind<
-        F,
-        C,
-        HKT.Intro<F, "K", K, K1>,
-        HKT.Intro<F, "Q", Q, Q1>,
-        HKT.Intro<F, "W", W, W1>,
-        HKT.Intro<F, "X", X, X1>,
-        HKT.Intro<F, "I", I, I1>,
-        HKT.Intro<F, "S", S, S1>,
-        HKT.Intro<F, "R", R, R1>,
-        HKT.Intro<F, "E", E, E1>,
-        A1
-      >
-    >,
-  ): HKT.Kind<
-    F,
-    C,
-    HKT.Mix<F, "K", [K, K1]>,
-    HKT.Mix<F, "Q", [Q, Q1]>,
-    HKT.Mix<F, "W", [W, W1]>,
-    HKT.Mix<F, "X", [X, X1]>,
-    HKT.Mix<F, "I", [I, I1]>,
-    HKT.Mix<F, "S", [S, S1]>,
-    HKT.Mix<F, "R", [R, R1]>,
-    HKT.Mix<F, "E", [E, E1]>,
-    A | A1
-  >;
-}
+export const ApplicativeExcept: ApplicativeExceptOps = {};
 
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF_
+ * @tsplus fluent fncts.Kind catchAll
  */
-export function catchJustF_<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn_<F, C>;
-export function catchJustF_<F>(F: ApplicativeExceptMin<HKT.FCoE<F>>): CatchJustFn_<HKT.FCoE<F>> {
-  return <K, Q, W, X, I, S, R, E, A, E1, A1>(
-    fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>,
-    f: (e: E) => Maybe<HKT.FK<F, K, Q, W, X, I, S, R, E1, A1>>,
-  ): HKT.FK<F, K, Q, W, X, I, S, R, E | E1, A | A1> =>
-    F.catchAll_(fa, (e) => f(e).match(() => F.fail(e) as HKT.FK<F, K, Q, W, X, I, S, R, E | E1, A | A1>, identity));
-}
-
-export interface CatchJustFn<F extends HKT, C = HKT.None> {
-  <E, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
-    f: (e: HKT.OrFix<C, "E", E>) => Maybe<HKT.Kind<F, C, K1, Q1, W1, X1, I1, S1, R1, E1, A1>>,
-  ): <K, Q, W, X, I, S, R, A>(
-    fa: HKT.Kind<
-      F,
-      C,
-      HKT.Intro<F, "K", K1, K>,
-      HKT.Intro<F, "Q", Q1, Q>,
-      HKT.Intro<F, "W", W1, W>,
-      HKT.Intro<F, "X", X1, X>,
-      HKT.Intro<F, "I", I1, I>,
-      HKT.Intro<F, "S", S1, S>,
-      HKT.Intro<F, "R", R1, R>,
-      HKT.Intro<F, "E", E1, E>,
-      A
-    >,
+export function catchAll<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
+  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  f: (
+    e: E,
   ) => HKT.Kind<
     F,
-    C,
-    HKT.Mix<F, "K", [K1, K]>,
-    HKT.Mix<F, "Q", [Q1, Q]>,
-    HKT.Mix<F, "W", [W1, W]>,
-    HKT.Mix<F, "X", [X1, X]>,
-    HKT.Mix<F, "I", [I1, I]>,
-    HKT.Mix<F, "S", [S1, S]>,
-    HKT.Mix<F, "R", [R1, R]>,
-    HKT.Mix<F, "E", [E1, E]>,
-    A | A1
-  >;
+    HKT.Intro<"K", K, K1>,
+    HKT.Intro<"Q", Q, Q1>,
+    HKT.Intro<"W", W, W1>,
+    HKT.Intro<"X", X, X1>,
+    HKT.Intro<"I", I, I1>,
+    HKT.Intro<"S", S, S1>,
+    HKT.Intro<"R", R, R1>,
+    HKT.Intro<"E", E, E1>,
+    A1
+  >,
+  /** @tsplus auto */ F: ApplicativeExcept<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K, K1]>,
+  HKT.Mix<"Q", [Q, Q1]>,
+  HKT.Mix<"W", [W, W1]>,
+  HKT.Mix<"X", [X, X1]>,
+  HKT.Mix<"I", [I, I1]>,
+  HKT.Mix<"S", [S, S1]>,
+  HKT.Mix<"R", [R, R1]>,
+  E1,
+  A | A1
+> {
+  return F.catchAll(fa, f);
 }
 
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF
+ * @tsplus fluent fncts.Kind catchJust
  */
-export function catchJustF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn<F, C>;
-export function catchJustF<F>(F: ApplicativeExceptMin<HKT.FCoE<F>>): CatchJustFn<HKT.FCoE<F>> {
-  return <K, Q, W, X, I, S, R, E, E1, A1>(f: (e: E) => Maybe<HKT.FK<F, K, Q, W, X, I, S, R, E1, A1>>) =>
-    <A>(fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>): HKT.FK<F, K, Q, W, X, I, S, R, E | E1, A | A1> =>
-      F.catchAll_(fa, (e) => f(e).match(() => F.fail(e) as HKT.FK<F, K, Q, W, X, I, S, R, E | E1, A | A1>, identity));
-}
-
-export interface EitherFn<F extends HKT, C = HKT.None> {
-  <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>): HKT.Kind<
-    F,
-    C,
-    K,
-    Q,
-    W,
-    X,
-    I,
-    S,
-    R,
-    never,
-    Either<HKT.OrFix<C, "E", E>, A>
-  >;
+export function catchJust<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1, X1, I1, S1, R1, E1, A1>(
+  fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  f: (
+    e: E,
+  ) => Maybe<
+    HKT.Kind<
+      F,
+      HKT.Intro<"K", K, K1>,
+      HKT.Intro<"Q", Q, Q1>,
+      HKT.Intro<"W", W, W1>,
+      HKT.Intro<"X", X, X1>,
+      HKT.Intro<"I", I, I1>,
+      HKT.Intro<"S", S, S1>,
+      HKT.Intro<"R", R, R1>,
+      HKT.Intro<"E", E, E1>,
+      A1
+    >
+  >,
+  /** @tsplus auto */ F: ApplicativeExcept<F>,
+): HKT.Kind<
+  F,
+  HKT.Mix<"K", [K, K1]>,
+  HKT.Mix<"Q", [Q, Q1]>,
+  HKT.Mix<"W", [W, W1]>,
+  HKT.Mix<"X", [X, X1]>,
+  HKT.Mix<"I", [I, I1]>,
+  HKT.Mix<"S", [S, S1]>,
+  HKT.Mix<"R", [R, R1]>,
+  HKT.Mix<"E", [E, E1]>,
+  A | A1
+> {
+  return fa.catchAll((e) => f(e).match(() => F.fail(e), identity) as HKT.Kind<F, K, Q1, W1, X1, I, S, R1, E1, A1>);
 }
 
 /**
- * @tsplus static fncts.ApplicativeExceptOps eitherF
+ * @tsplus fluent fncts.Kind either
  */
-export function eitherF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): EitherFn<F, C>;
-export function eitherF<F>(F: ApplicativeExceptMin<HKT.FCoE<F>>): EitherFn<HKT.FCoE<F>> {
-  return (fa) => F.catchAll_(F.map_(fa, Either.right), (e) => F.pure(Either.left(e)));
+export function either<F extends HKT, K, Q, W, X, I, S, R, E, A>(
+  self: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>,
+  /** @tsplus auto */ F: ApplicativeExcept<F>,
+): HKT.Kind<F, K, Q, W, X, I, S, R, never, Either<E, A>> {
+  return self.map(Either.right, F).catchAll((e) => F.pure(Either.left(e)));
 }