@fncts/base 0.0.3 → 0.0.4

package/json/TheseJson.d.ts

@@ -0,0 +1,26 @@
+import { Decoder } from "@fncts/base/data/Decoder";
+export interface LeftJson<E> {
+    readonly _tag: "Left";
+    readonly left: E;
+}
+export interface RightJson<A> {
+    readonly _tag: "Right";
+    readonly right: A;
+}
+export interface BothJson<E, A> {
+    readonly _tag: "Both";
+    readonly left: E;
+    readonly right: A;
+}
+export declare type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
+/**
+ * @tsplus type fncts.TheseJsonOps
+ */
+export interface TheseJsonOps {
+}
+export declare const TheseJson: TheseJsonOps;
+/**
+ * @tsplus static fncts.TheseJsonOps getDecoder
+ * @tsplus location "@fncts/base/json/TheseJson"
+ */
+export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>>;

package/optics/Traversal/api/fromTraversable.d.ts

@@ -5,4 +5,4 @@ import { PTraversal } from "@fncts/base/optics/Traversal/definition";
  * @tsplus static fncts.optics.PTraversalOps fromTraversable
  * @tsplus location "@fncts/base/optics/Traversal/api/fromTraversable"
  */
-export declare function fromTraversable<T extends HKT, C = HKT.None>(T: P.Traversable<T, C>): <A, B, K = HKT.Low<T, "K">, Q = HKT.Low<T, "Q">, W = HKT.Low<T, "W">, X = HKT.Low<T, "X">, I = HKT.Low<T, "I">, S = HKT.Low<T, "S">, R = HKT.Low<T, "R">, E = HKT.Low<T, "E">, K1 = HKT.Low<T, "K">, Q1 = HKT.Low<T, "Q">, W1 = HKT.Low<T, "W">, X1 = HKT.Low<T, "X">, I1 = HKT.Low<T, "I">, S1 = HKT.Low<T, "S">, R1 = HKT.Low<T, "R">, E1 = HKT.Low<T, "E">>() => PTraversal<HKT.Kind<T, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<T, C, K1, Q1, W1, X1, I1, S1, R1, E1, B>, A, B>;
+export declare function fromTraversable<T extends HKT>(T: P.Traversable<T>): <A, B, K = any, Q = unknown, W = never, X = never, I = any, S = any, R = unknown, E = never>() => PTraversal<import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, A>, import("@fncts/typelevel/HKT").HKT.Kind<T, K, Q, W, X, I, S, R, E, B>, A, B>;

package/optics/Traversal/definition.d.ts

@@ -6,11 +6,12 @@ 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>;
 }
 /**
  * @tsplus type fncts.optics.PTraversalOps
@@ -38,9 +39,3 @@ export interface TraversalOps extends PTraversalOps {
  * @tsplus location "@fncts/base/optics/Traversal/definition"
  */
 export declare function mkTraversal<S, A>(F: PTraversalMin<S, S, A, A>): Traversal<S, A>;
-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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "dependencies": {
-    "@fncts/typelevel": "0.0.3"
+    "@fncts/typelevel": "0.0.4"
   },
   "exports": {
     "./*": {

package/typeclass/Align.d.ts

@@ -1,11 +1,10 @@
 import { HKT } from "@fncts/typelevel/HKT";
-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
@@ -13,9 +12,3 @@ export interface Align<F extends HKT, FC = HKT.None> extends Semialign<F, FC>, N
 export interface AlignOps {
 }
 export declare const Align: AlignOps;
-export declare type AlignMin<F extends HKT, FC = HKT.None> = SemialignMin<F, FC> & NilMin<F, FC>;
-/**
- * @tsplus static fncts.AlignOps __call
- * @tsplus location "@fncts/base/typeclass/Align"
- */
-export declare function mkAlign<F extends HKT, FC = HKT.None>(F: AlignMin<F, FC>): Align<F, FC>;

package/typeclass/Alt.d.ts

@@ -1,12 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Functor } from "@fncts/base/typeclass/Functor";
+import { Lazy } from "@fncts/base/data/function/definition";
+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]>>;
 }
 /**
  * @tsplus type fncts.AltOps
@@ -14,17 +13,5 @@ export interface Alt<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
 export interface AltOps {
 }
 export declare const Alt: AltOps;
-export declare type AltMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-    readonly alt_: alt_<F, FC>;
-};
-/**
- * @tsplus static fncts.AltOps __call
- * @tsplus location "@fncts/base/typeclass/Alt"
- */
-export declare function mkAlt<F extends HKT, C = HKT.None>(F: AltMin<F, C>): Alt<F, C>;
-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<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]>>;
-}
+export declare 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, 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]>>;

package/typeclass/Alternative.d.ts

@@ -1,13 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-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
@@ -15,9 +13,3 @@ export interface Alternative<F extends HKT, FC = HKT.None> extends Applicative<F
 export interface AlternativeOps {
 }
 export declare const Alternative: AlternativeOps;
-export declare type AlternativeMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & NilMin<F, FC> & AltMin<F, FC>;
-/**
- * @tsplus static fncts.AlternativeOps __call
- * @tsplus location "@fncts/base/typeclass/Alternative"
- */
-export declare function mkAlternative<F extends HKT, C = HKT.None>(F: AlternativeMin<F, C>): Alternative<F, C>;

package/typeclass/Applicative.d.ts

@@ -1,9 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { ApplyMin } from "@fncts/base/typeclass/Apply";
-import type { PointedMin } 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> {
+import type { Apply } from "@fncts/base/typeclass/Apply";
+import type { Pointed } from "@fncts/base/typeclass/Pointed";
+export interface Applicative<F extends HKT> extends Apply<F>, Pointed<F> {
 }
 /**
  * @tsplus type fncts.ApplicativeOps
@@ -11,10 +9,3 @@ export interface Applicative<F extends HKT, FC = HKT.None> extends Apply<F, FC>,
 export interface ApplicativeOps {
 }
 export declare const Applicative: ApplicativeOps;
-export declare type ApplicativeMin<F extends HKT, FC = HKT.None> = ApplyMin<F, FC> & PointedMin<F, FC>;
-/**
- * @tsplus static fncts.ApplicativeOps __call
- * @tsplus location "@fncts/base/typeclass/Applicative"
- */
-export declare function mkApplicative<F extends HKT, FC = HKT.None>(F: ApplicativeMin<F, FC>): Applicative<F, FC>;
-export declare 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/typeclass/ApplicativeExcept.d.ts

@@ -1,18 +1,13 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { HKT } from "@fncts/typelevel/HKT";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
-import type { Fail, FailMin } from "@fncts/base/typeclass/Fail";
-import { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Fail } from "@fncts/base/typeclass/Fail";
 /**
  * @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>;
+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: E) => 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>): 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>;
 }
 /**
  * @tsplus type fncts.ApplicativeExceptOps
@@ -20,41 +15,21 @@ export interface ApplicativeExcept<F extends HKT.CovariantE, C = HKT.None> exten
 export interface ApplicativeExceptOps {
 }
 export declare const ApplicativeExcept: ApplicativeExceptOps;
-export declare 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
- * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
- */
-export declare function mkApplicativeExcept<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): ApplicativeExcept<F, C>;
-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>, f: (e: HKT.OrFix<C, "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>, 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]>, 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>;
-}
-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>;
-}
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF_
+ * @tsplus fluent fncts.Kind catchAll
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function catchJustF_<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn_<F, C>;
-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>) => 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>;
-}
+export declare 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, 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>;
 /**
- * @tsplus static fncts.ApplicativeExceptOps catchJustF
+ * @tsplus fluent fncts.Kind catchJust
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function catchJustF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): CatchJustFn<F, C>;
-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 declare 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>;
 /**
- * @tsplus static fncts.ApplicativeExceptOps eitherF
+ * @tsplus fluent fncts.Kind either
  * @tsplus location "@fncts/base/typeclass/ApplicativeExcept"
  */
-export declare function eitherF<F extends HKT.CovariantE, C = HKT.None>(F: ApplicativeExceptMin<F, C>): EitherFn<F, C>;
+export declare 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>>;

package/typeclass/Apply.d.ts

@@ -1,20 +1,12 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
+import type { Functor } from "@fncts/base/typeclass/Functor";
 import type { Semimonoidal } from "@fncts/base/typeclass/Semimonoidal";
 import type { Object } from "@fncts/typelevel";
-import { Functor } from "@fncts/base/typeclass/Functor";
 /**
  * @tsplus type fncts.Apply
  */
-export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>, Functor<F, FC> {
-    readonly ap_: ap_<F, FC>;
-    readonly ap: ap<F, FC>;
-    readonly apFirst_: apFirst_<F, FC>;
-    readonly apFirst: apFirst<F, FC>;
-    readonly apSecond_: apSecond_<F, FC>;
-    readonly apSecond: apSecond<F, FC>;
-    readonly zipWith_: zipWith_<F, FC>;
-    readonly zipWith: zipWith<F, FC>;
+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>, 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): 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>;
 }
 /**
  * @tsplus type fncts.ApplyOps
@@ -22,82 +14,59 @@ export interface Apply<F extends HKT, FC = HKT.None> extends Semimonoidal<F, FC>
 export interface ApplyOps {
 }
 export declare const Apply: ApplyOps;
-export declare type ApplyMin<F extends HKT, FC = HKT.None> = {
-    readonly ap_: ap_<F, FC>;
-    zipWith_: zipWith_<F, FC>;
-} & FunctorMin<F, FC>;
 /**
- * @tsplus static fncts.ApplyOps __call
+ * @tsplus fluent fncts.Kind zipWith
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function mkApply<F extends HKT, FC = HKT.None>(F: ApplyMin<F, FC>): Apply<F, FC>;
-export interface ap_<F extends HKT, FC = HKT.None> {
-    <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, 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>): HKT.Kind<F, 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>;
-}
-export interface ap<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A>(fa: HKT.Kind<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, 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: A) => B>) => HKT.Kind<F, 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>;
-}
-export interface apFirst_<F extends HKT, FC = HKT.None> {
-    <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, 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>): HKT.Kind<F, 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>;
-}
-export interface apFirst<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <K2, Q2, W2, X2, I2, S2, R2, E2, A>(fa: HKT.Kind<F, 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>) => HKT.Kind<F, 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>;
-}
-export interface apSecond_<F extends HKT, FC = HKT.None> {
-    <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, 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>): HKT.Kind<F, 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>;
-}
-export interface apSecond<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, B>(fb: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, B>): <K2, Q2, W2, X2, I2, S2, R2, E2, A>(fa: HKT.Kind<F, 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>) => HKT.Kind<F, 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>;
-}
-export interface zipWith_<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B, C>(fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, fb: HKT.Kind<F, 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) => C): HKT.Kind<F, 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]>, C>;
-}
-export interface zipWith<F extends HKT, FC = HKT.None> {
-    <A, K1, Q1, W1, X1, I1, S1, R1, E1, B, C>(fb: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, B>, f: (a: A, b: B) => C): <K2, Q2, W2, X2, I2, S2, R2, E2>(fa: HKT.Kind<F, 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>) => HKT.Kind<F, 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]>, C>;
-}
-export interface apS_<F extends HKT, FC = HKT.None> {
-    <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, 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>): HKT.Kind<F, 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;
-    }>;
-}
-export interface apS<F extends HKT, FC = HKT.None> {
-    <BN extends string, K1, Q1, W1, X1, I1, S1, R1, E1, A1, A>(name: Exclude<BN, keyof A>, fb: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A1>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, 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, FC, 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]>, {
-        [K in keyof A | BN]: K extends keyof A ? A[K] : A1;
-    }>;
-}
-export interface sequenceS<F extends HKT, FC = HKT.None> {
-    <KS extends Readonly<Record<string, HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "X", X, 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<F, "K">, Q = HKT.Low<F, "Q">, W = HKT.Low<F, "W">, X = HKT.Low<F, "X">, 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<Record<string, HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "X", X, 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>>>): HKT.Kind<F, FC, InferMixStruct<F, FC, "K", K, KS>, InferMixStruct<F, FC, "Q", Q, KS>, InferMixStruct<F, FC, "W", W, KS>, InferMixStruct<F, FC, "X", X, 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, FC, "A", KS[K]>;
-    }>;
-}
+export declare 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>;
 /**
- * @tsplus static fncts.ApplyOps sequenceSF
+ * @tsplus fluent fncts.Kind ap
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function sequenceSF<F extends HKT, C = HKT.None>(F: ApplyMin<F, C>): sequenceS<F, C>;
-export interface sequenceT<F extends HKT, FC = HKT.None> {
-    <KT extends readonly [
-        HKT.Kind<F, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "X", X, 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, FC, HKT.Intro<F, "K", K, any>, HKT.Intro<F, "Q", Q, any>, HKT.Intro<F, "W", W, any>, HKT.Intro<F, "X", X, 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<F, "K">, Q = HKT.Low<F, "Q">, W = HKT.Low<F, "W">, X = HKT.Low<F, "X">, I = HKT.Low<F, "I">, S = HKT.Low<F, "S">, R = HKT.Low<F, "R">, E = HKT.Low<F, "E">>(...t: KT): HKT.Kind<F, FC, InferMixTuple<F, FC, "K", K, KT>, InferMixTuple<F, FC, "Q", Q, KT>, InferMixTuple<F, FC, "W", W, KT>, InferMixTuple<F, FC, "X", X, 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, FC, "A", KT[K]>;
-    }>;
-}
+export declare 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>, 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>, A>, 
+/** @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]>, B>;
+/**
+ * @tsplus fluent fncts.Kind apFirst
+ * @tsplus location "@fncts/base/typeclass/Apply"
+ */
+export declare 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>, 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>, B>, 
+/** @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]>, A>;
+/**
+ * @tsplus fluent fncts.Kind apSecond
+ * @tsplus location "@fncts/base/typeclass/Apply"
+ */
+export declare 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>, 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>, B>, 
+/** @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]>, B>;
+export declare 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>, 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>, B>, 
+/** @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]>, {
+    [K in keyof A | BN]: K extends keyof A ? A[K] : B;
+}>;
 /**
- * @tsplus static fncts.ApplyOps sequenceTF
+ * @tsplus static fncts.ApplyOps sequenceS
  * @tsplus location "@fncts/base/typeclass/Apply"
  */
-export declare function sequenceTF<F extends HKT, FC = HKT.None>(F: ApplyMin<F, FC>): sequenceT<F, FC>;
+export declare function sequenceS<F extends HKT, 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>, 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">>(r: Object.EnforceNonEmpty<KS> & 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>, A>>>, 
+/** @tsplus auto */ F: Apply<F>): 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>, {
+    [K in keyof KS]: HKT.Infer<F, "A", KS[K]>;
+}>;
+export declare function sequenceT<F extends HKT, 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>, 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>, 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">>(t: [...KT], 
+/** @tsplus auto */ F: Apply<F>): 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>, {
+    [K in keyof KT]: HKT.Infer<F, "A", KT[K]>;
+}>;
 /**
  * @internal
  */
-declare type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<F, P, T, {
-    [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]>;
+declare type InferMixStruct<F extends HKT, P extends HKT.ParamName, T, KS> = HKT.MixStruct<P, T, {
+    [K in keyof KS]: HKT.Infer<F, P, KS[K]>;
 }>;
 /**
  * @internal
  */
-declare 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, FC, P, KT[K]>;
+declare type InferMixTuple<F extends HKT, P extends HKT.ParamName, T, KT> = HKT.MixStruct<P, T, {
+    [K in keyof KT & number]: HKT.Infer<F, P, KT[K]>;
 }>;
 export {};

package/typeclass/Chain.d.ts

@@ -1,12 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Functor } from "@fncts/base/typeclass/Functor";
-export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-    readonly flatMap_: flatMap_<F, FC>;
-    readonly flatMap: flatMap<F, FC>;
-    readonly flatten: flatten<F, FC>;
-    readonly tap_: tap_<F, FC>;
-    readonly tap: tap<F, FC>;
+import type { Functor } from "@fncts/base/typeclass/Functor";
+export interface FlatMap<F extends HKT> extends Functor<F> {
+    flatMap<K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, f: (a: A) => 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>): 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]>, B>;
 }
 /**
  * @tsplus type fncts.FlatMapOps
@@ -14,26 +9,21 @@ export interface FlatMap<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
 export interface FlatMapOps {
 }
 export declare const FlatMap: FlatMapOps;
-export declare type ChainMin<F extends HKT, FC = HKT.None> = {
-    readonly flatMap_: flatMap_<F, FC>;
-} & FunctorMin<F, FC>;
 /**
- * @tsplus static fncts.FlatMapOps __call
+ * @tsplus fluent fncts.Kind flatMap
  * @tsplus location "@fncts/base/typeclass/Chain"
  */
-export declare function mkFlatMap<F extends HKT, FC = HKT.None>(F: ChainMin<F, FC>): FlatMap<F, FC>;
-export interface flatMap_<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, f: (a: A) => HKT.Kind<F, 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>): HKT.Kind<F, 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>;
-}
-export interface flatMap<F extends HKT, TC = HKT.None> {
-    <K2, Q2, W2, X2, I2, S2, R2, E2, B, A>(f: (a: A) => HKT.Kind<F, TC, K2, Q2, W2, X2, I2, S2, R2, E2, B>): <K1, Q1, W1, X1, I1, S1, R1, E1>(ma: HKT.Kind<F, TC, HKT.Intro<F, "K", K2, K1>, HKT.Intro<F, "Q", Q2, Q1>, HKT.Intro<F, "W", W2, W1>, HKT.Intro<F, "X", X2, X1>, HKT.Intro<F, "I", I2, I1>, HKT.Intro<F, "S", S2, S1>, HKT.Intro<F, "R", R2, R1>, HKT.Intro<F, "E", E2, E1>, A>) => HKT.Kind<F, TC, HKT.Mix<F, "K", [K2, K1]>, HKT.Mix<F, "Q", [Q2, Q1]>, HKT.Mix<F, "W", [W2, W1]>, HKT.Mix<F, "X", [X2, X1]>, HKT.Mix<F, "I", [I2, I1]>, HKT.Mix<F, "S", [S2, S1]>, HKT.Mix<F, "R", [R2, R1]>, HKT.Mix<F, "E", [E2, E1]>, B>;
-}
-export interface flatten<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2>(mma: HKT.Kind<F, FC, K2, Q2, W2, X2, I2, S2, R2, E2, HKT.Kind<F, FC, HKT.Intro<F, "K", K2, K1>, HKT.Intro<F, "Q", Q2, Q1>, HKT.Intro<F, "W", W2, W1>, HKT.Intro<F, "X", X2, X1>, HKT.Intro<F, "I", I2, I1>, HKT.Intro<F, "S", S2, S1>, HKT.Intro<F, "R", R2, R1>, HKT.Intro<F, "E", E2, E1>, A>>): HKT.Kind<F, FC, HKT.Mix<F, "K", [K2, K1]>, HKT.Mix<F, "Q", [Q2, Q1]>, HKT.Mix<F, "W", [W2, W1]>, HKT.Mix<F, "X", [X2, X1]>, HKT.Mix<F, "I", [I2, I1]>, HKT.Mix<F, "S", [S2, S1]>, HKT.Mix<F, "R", [R2, R1]>, HKT.Mix<F, "E", [E2, E1]>, A>;
-}
-export interface tap_<F extends HKT, FC = HKT.None> {
-    <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(ma: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>, f: (a: A) => HKT.Kind<F, 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>): HKT.Kind<F, 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>;
-}
-export interface tap<F extends HKT, TC = HKT.None> {
-    <K2, Q2, W2, X2, I2, S2, R2, E2, B, A>(f: (a: A) => HKT.Kind<F, TC, K2, Q2, W2, X2, I2, S2, R2, E2, B>): <K1, Q1, W1, X1, I1, S1, R1, E1>(ma: HKT.Kind<F, TC, HKT.Intro<F, "K", K2, K1>, HKT.Intro<F, "Q", Q2, Q1>, HKT.Intro<F, "W", W2, W1>, HKT.Intro<F, "X", X2, X1>, HKT.Intro<F, "I", I2, I1>, HKT.Intro<F, "S", S2, S1>, HKT.Intro<F, "R", R2, R1>, HKT.Intro<F, "E", E2, E1>, A>) => HKT.Kind<F, TC, HKT.Mix<F, "K", [K2, K1]>, HKT.Mix<F, "Q", [Q2, Q1]>, HKT.Mix<F, "W", [W2, W1]>, HKT.Mix<F, "X", [X2, X1]>, HKT.Mix<F, "I", [I2, I1]>, HKT.Mix<F, "S", [S2, S1]>, HKT.Mix<F, "R", [R2, R1]>, HKT.Mix<F, "E", [E2, E1]>, A>;
-}
+export declare function flatMap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, f: (a: A) => 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>, 
+/** @tsplus auto */ F: FlatMap<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]>, B>;
+/**
+ * @tsplus fluent fncts.Kind flatten
+ * @tsplus location "@fncts/base/typeclass/Chain"
+ */
+export declare function flatten<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2>(mma: HKT.Kind<F, K2, Q2, W2, X2, I2, S2, R2, E2, HKT.Kind<F, HKT.Intro<"K", K2, K1>, HKT.Intro<"Q", Q2, Q1>, HKT.Intro<"W", W2, W1>, HKT.Intro<"X", X2, X1>, HKT.Intro<"I", I2, I1>, HKT.Intro<"S", S2, S1>, HKT.Intro<"R", R2, R1>, HKT.Intro<"E", E2, E1>, A>>, 
+/** @tsplus auto */ F: FlatMap<F>): HKT.Kind<F, HKT.Mix<"K", [K2, K1]>, HKT.Mix<"Q", [Q2, Q1]>, HKT.Mix<"W", [W2, W1]>, HKT.Mix<"X", [X2, X1]>, HKT.Mix<"I", [I2, I1]>, HKT.Mix<"S", [S2, S1]>, HKT.Mix<"R", [R2, R1]>, HKT.Mix<"E", [E2, E1]>, A>;
+/**
+ * @tsplus fluent fncts.Kind tap
+ * @tsplus location "@fncts/base/typeclass/Chain"
+ */
+export declare function tap<F extends HKT, K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(ma: HKT.Kind<F, K1, Q1, W1, X1, I1, S1, R1, E1, A>, f: (a: A) => 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>, 
+/** @tsplus auto */ F: FlatMap<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]>, A>;

package/typeclass/Closure.d.ts

@@ -2,8 +2,7 @@
  * @tsplus type fncts.Closure
  */
 export interface Closure<A> {
-    readonly combine_: (x: A, y: A) => A;
-    readonly combine: (y: A) => (x: A) => A;
+    readonly combine: (x: A, y: A) => A;
 }
 /**
  * @tsplus type fncts.ClosureOps
@@ -11,17 +10,8 @@ export interface Closure<A> {
 export interface ClosureOps {
 }
 export declare const Closure: ClosureOps;
-export declare type ClosureMin<A> = {
-    combine_: combine_<A>;
-};
 /**
  * @tsplus static fncts.ClosureOps __call
  * @tsplus location "@fncts/base/typeclass/Closure"
  */
-export declare function mkClosure<A>(F: ClosureMin<A>): Closure<A>;
-export interface combine_<A> {
-    (x: A, y: A): A;
-}
-export interface combine<A> {
-    (y: A): (x: A) => A;
-}
+export declare function mkClosure<A>(F: Closure<A>): Closure<A>;

package/typeclass/Eq/definition.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @tsplus type fncts.Eq
+ */
+export interface Eq<A> {
+    readonly equals: (x: A, y: A) => boolean;
+}
+/**
+ * @tsplus type fncts.EqOps
+ */
+export interface EqOps {
+}
+export declare const Eq: EqOps;
+/**
+ * @tsplus static fncts.EqOps __call
+ * @tsplus location "@fncts/base/typeclass/Eq/definition"
+ */
+export declare function mkEq<A>(E: Eq<A>): Eq<A>;

package/typeclass/Eq/derivations.d.ts

@@ -0,0 +1,24 @@
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+import { Eq } from "@fncts/base/typeclass/Eq/definition";
+/**
+ * @tsplus derive fncts.Eq lazy
+ * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ */
+export declare function deriveLazy<A>(fn: (_: Eq<A>) => Eq<A>): Eq<A>;
+/**
+ * @tsplus derive fncts.Eq<_> 20
+ * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [K in RequiredKeys<A>]: Eq<A[K]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [K in OptionalKeys<A>]: Eq<NonNullable<A[K]>>;
+        }
+    ])
+] : never): Eq<A>;