@fncts/base 0.0.3 → 0.0.6

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>;

package/typeclass/Eq.d.ts

@@ -1,27 +1,2 @@
-/**
- * @tsplus type fncts.Eq
- */
-export interface Eq<A> {
-    readonly equals_: equals_<A>;
-    readonly equals: equals<A>;
-}
-/**
- * @tsplus type fncts.EqOps
- */
-export interface EqOps {
-}
-export declare const Eq: EqOps;
-export declare type EqMin<A> = {
-    readonly equals_: equals_<A>;
-};
-/**
- * @tsplus static fncts.EqOps __call
- * @tsplus location "@fncts/base/typeclass/Eq"
- */
-export declare function mkEq<A>(F: EqMin<A>): Eq<A>;
-export interface equals_<A> {
-    (x: A, y: A): boolean;
-}
-export interface equals<A> {
-    (y: A): (x: A) => boolean;
-}
+export * from "./Eq/definition.js";
+export {} from "./Eq/derivations.js";

package/typeclass/Fail.d.ts

@@ -2,22 +2,16 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.Fail
  */
-export interface Fail<F extends HKT, TC = HKT.None> extends HKT.Typeclass<F, TC> {
-    readonly fail: fail<F, TC>;
+export interface Fail<F extends HKT> extends HKT.Typeclass<F> {
+    fail<E, K = HKT.Low<"K">, Q = HKT.Low<"Q">, W = HKT.Low<"W">, X = HKT.Low<"X">, I = HKT.Low<"I">, S = HKT.Low<"S">, R = HKT.Low<"R">, A = never>(e: E): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
 }
 /**
  * @tsplus type fncts.FailOps
  */
 export interface FailOps {
 }
-export declare type FailMin<F extends HKT, C = HKT.None> = {
-    readonly fail: fail<F, C>;
-};
 /**
- * @tsplus static fncts.FailOps __call
+ * @tsplus static fncts.FailOps fail
  * @tsplus location "@fncts/base/typeclass/Fail"
  */
-export declare function mkFail<F extends HKT, C = HKT.None>(F: FailMin<F, C>): Fail<F, C>;
-export interface fail<F extends HKT, C = HKT.None> {
-    <E, 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">, A = never>(e: HKT.OrFix<C, "E", E>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>;
-}
+export declare function fail<F extends HKT, E, K = HKT.Low<"K">, Q = HKT.Low<"Q">, W = HKT.Low<"W">, X = HKT.Low<"X">, I = HKT.Low<"I">, S = HKT.Low<"S">, R = HKT.Low<"R">, A = never>(e: E, /** @tsplus auto */ F: Fail<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;

package/typeclass/Filterable.d.ts

@@ -1,22 +1,19 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-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.Filterable
  */
-export interface Filterable<F extends HKT, FC = HKT.None> extends Functor<F, FC> {
-    readonly filter_: filter_<F, FC>;
-    readonly filter: filter<F, FC>;
-    readonly filterMap_: filterMap_<F, FC>;
-    readonly filterMap: filterMap<F, FC>;
-    readonly partition_: partition_<F, FC>;
-    readonly partition: partition<F, FC>;
-    readonly partitionMap_: partitionMap_<F, FC>;
-    readonly partitionMap: partitionMap<F, FC>;
+export interface Filterable<F extends HKT> extends Functor<F> {
+    filter<K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+    filter<K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, predicate: Predicate<A>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+    filterMap<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Maybe<B>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+    partition<K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
+    partition<K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, predicate: Predicate<A>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, A>];
+    partitionMap<K, Q, W, X, I, S, R, E, A, B, B1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Either<B, B1>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>];
 }
 /**
  * @tsplus type fncts.FilterableOps
@@ -24,45 +21,27 @@ export interface Filterable<F extends HKT, FC = HKT.None> extends Functor<F, FC>
 export interface FilterableOps {
 }
 export declare const Filterable: FilterableOps;
-export declare type FilterableMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-    readonly filter_: filter_<F, FC>;
-    readonly filterMap_: filterMap_<F, FC>;
-    readonly partition_: partition_<F, FC>;
-    readonly partitionMap_: partitionMap_<F, FC>;
-};
 /**
- * @tsplus static fncts.FilterableOps __call
+ * @tsplus fluent fncts.Kind filter
  * @tsplus location "@fncts/base/typeclass/Filterable"
  */
-export declare function mkFilterable<F extends HKT, FC = HKT.None>(F: FilterableMin<F, FC>): Filterable<F, FC>;
-export interface filter_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-    <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, predicate: Predicate<A>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>;
-}
-export interface filter<F extends HKT, C = HKT.None> {
-    <A, B extends A>(refinement: Refinement<A, B>): <K, Q, W, X, I, S, R, E>(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, E, B>;
-    <A>(predicate: Predicate<A>): <K, Q, W, X, I, S, R, E>(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, E, A>;
-}
-export interface filterMap_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Maybe<B>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface filterMap<F extends HKT, C = HKT.None> {
-    <A, B>(f: (a: A) => Maybe<B>): <K, Q, W, X, I, S, R, E>(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, E, B>;
-}
-export interface partition_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>): readonly [HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>];
-    <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, predicate: Predicate<A>): readonly [
-        HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>,
-        HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>
-    ];
-}
-export interface partition<F extends HKT, C = HKT.None> {
-    <A, B extends A>(refinement: Refinement<A, B>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => readonly [HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>];
-    <A>(predicate: Predicate<A>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => readonly [HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>];
-}
-export interface partitionMap_<F extends HKT, C = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B, B1>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Either<B, B1>): readonly [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, B1>];
-}
-export interface partitionMap<F extends HKT, C = HKT.None> {
-    <A, B, B1>(f: (a: A) => Either<B, B1>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => readonly [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, B1>];
-}
+export declare function filter<F extends HKT, K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>, 
+/** @tsplus auto */ F: Filterable<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+/**
+ * @tsplus fluent fncts.Kind filterMap
+ * @tsplus location "@fncts/base/typeclass/Filterable"
+ */
+export declare function filterMap<F extends HKT, K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Maybe<B>, 
+/** @tsplus auto */ F: Filterable<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+/**
+ * @tsplus fluent fncts.Kind partition
+ * @tsplus location "@fncts/base/typeclass/Filterable"
+ */
+export declare function partition<F extends HKT, K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: Refinement<A, B>, 
+/** @tsplus auto */ F: Filterable<F>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
+/**
+ * @tsplus fluent fncts.Kind partitionMap
+ * @tsplus location "@fncts/base/typeclass/Filterable"
+ */
+export declare function partitionMap<F extends HKT, K, Q, W, X, I, S, R, E, A, B, B1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (a: A) => Either<B, B1>, 
+/** @tsplus auto */ F: Filterable<F>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>];

package/typeclass/FilterableWithIndex.d.ts

@@ -1,24 +1,20 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import { PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { FilterableMin } from "@fncts/base/typeclass/Filterable";
-import type { FunctorWithIndexMin } from "@fncts/base/typeclass/FunctorWithIndex";
-import { Filterable } from "@fncts/base/typeclass/Filterable";
-import { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
+import type { Filterable } from "@fncts/base/typeclass/Filterable";
+import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
 /**
  * @tsplus type fncts.FilterableWithIndex
  */
-export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends FunctorWithIndex<F, FC>, Filterable<F, FC> {
-    readonly filterWithIndex_: filterWithIndex_<F, FC>;
-    readonly filterWithIndex: filterWithIndex<F, FC>;
-    readonly filterMapWithIndex_: filterMapWithIndex_<F, FC>;
-    readonly filterMapWithIndex: filterMapWithIndex<F, FC>;
-    readonly partitionWithIndex_: partitionWithIndex_<F, FC>;
-    readonly partitionWithIndex: partitionWithIndex<F, FC>;
-    readonly partitionMapWithIndex_: partitionMapWithIndex_<F, FC>;
-    readonly partitionMapWithIndex: partitionMapWithIndex<F, FC>;
+export interface FilterableWithIndex<F extends HKT> extends FunctorWithIndex<F>, Filterable<F> {
+    filterWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+    filterWithIndex<K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>): HKT.Kind<F, K, Q, W, X, I, S, R, E, A>;
+    filterMapWithIndex<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, K>, a: A) => Maybe<B>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+    partitionWithIndex<K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, refinement: RefinementWithIndex<HKT.IndexFor<F, K>, A, B>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B>];
+    partitionWithIndex<K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, predicate: PredicateWithIndex<HKT.IndexFor<F, K>, A>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, K, Q, W, X, I, S, R, E, A>];
+    partitionMapWithIndex<K, Q, W, X, I, S, R, E, A, B, B1>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, K>, a: A) => Either<B, B1>): readonly [HKT.Kind<F, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, K, Q, W, X, I, S, R, E, B1>];
 }
 /**
  * @tsplus type fncts.FilterableWithIndexOps
@@ -26,42 +22,3 @@ export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends Funct
 export interface FilterableWithIndexOps {
 }
 export declare const FilterableWithIndex: FilterableWithIndexOps;
-export declare type FilterableWithIndexMin<F extends HKT, FC = HKT.None> = FunctorWithIndexMin<F, FC> & FilterableMin<F, FC> & {
-    readonly filterWithIndex_: filterWithIndex_<F, FC>;
-    readonly filterMapWithIndex_: filterMapWithIndex_<F, FC>;
-    readonly partitionWithIndex_: partitionWithIndex_<F, FC>;
-    readonly partitionMapWithIndex_: partitionMapWithIndex_<F, FC>;
-};
-/**
- * @tsplus static fncts.FilterableWithIndexOps __call
- * @tsplus location "@fncts/base/typeclass/FilterableWithIndex"
- */
-export declare function mkFilterableWithIndex<F extends HKT, FC = HKT.None>(F: FilterableWithIndexMin<F, FC>): FilterableWithIndex<F, FC>;
-export interface filterWithIndex_<F extends HKT, FC = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, refinement: RefinementWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A, B>): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-    <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, predicate: PredicateWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A>): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-}
-export interface filterWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B extends A>(refinement: RefinementWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A, B>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-    <K, A>(predicate: PredicateWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>;
-}
-export interface filterMapWithIndex_<F extends HKT, FC = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => Maybe<B>): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-}
-export interface filterMapWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => Maybe<B>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>;
-}
-export interface partitionWithIndex_<F extends HKT, FC = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B extends A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, refinement: RefinementWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A, B>): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-    <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, predicate: PredicateWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A>): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-}
-export interface partitionWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B extends A>(refinement: RefinementWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A, B>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>];
-    <K, A>(predicate: PredicateWithIndex<HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, A>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>];
-}
-export interface partitionMapWithIndex_<F extends HKT, FC = HKT.None> {
-    <K, Q, W, X, I, S, R, E, A, B, B1>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => Either<B, B1>): readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
-}
-export interface partitionMapWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B, B1>(f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => Either<B, B1>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => readonly [HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B1>];
-}