@fncts/base 0.0.2 → 0.0.5

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

package/typeclass/Foldable.d.ts

@@ -4,13 +4,9 @@ import type { Monoid } from "@fncts/base/typeclass/Monoid";
 /**
  * @tsplus type fncts.Foldable
  */
-export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-    readonly foldLeft_: foldLeft_<F, FC>;
-    readonly foldLeft: foldLeft<F, FC>;
-    readonly foldRight_: foldRight_<F, FC>;
-    readonly foldRight: foldRight<F, FC>;
-    readonly foldMap_: foldMap_<F, FC>;
-    readonly foldMap: foldMap<F, FC>;
+export interface Foldable<F extends HKT> extends HKT.Typeclass<F> {
+    foldLeft<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, b: B, f: (b: B, a: A) => B): B;
+    foldRight<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
 }
 /**
  * @tsplus type fncts.FoldableOps
@@ -18,30 +14,22 @@ export interface Foldable<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F,
 export interface FoldableOps {
 }
 export declare const Foldable: FoldableOps;
-export declare type FoldableMin<F extends HKT, FC = HKT.None> = {
-    readonly foldLeft_: foldLeft_<F, FC>;
-    readonly foldRight_: foldRight_<F, FC>;
-};
 /**
- * @tsplus static fncts.FoldableOps __call
+ * @tsplus fluent fncts.Kind foldLeft
  * @tsplus location "@fncts/base/typeclass/Foldable"
  */
-export declare function mkFoldable<F extends HKT, FC = HKT.None>(F: FoldableMin<F, FC>): Foldable<F, FC>;
-export interface foldLeft_<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>, b: B, f: (b: B, a: A) => B): B;
-}
-export interface foldLeft<F extends HKT, FC = HKT.None> {
-    <A, B>(b: B, f: (b: B, a: A) => B): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
-}
-export interface foldRight_<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>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B>;
-}
-export interface foldRight<F extends HKT, FC = HKT.None> {
-    <A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
-}
-export interface foldMap_<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (a: A) => M) => M;
-}
-export interface foldMap<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <A>(f: (a: A) => M) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => M;
-}
+export declare function foldLeft<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>, b: B, f: (b: B, a: A) => B, 
+/** @tsplus auto */ F: Foldable<F>): B;
+/**
+ * @tsplus fluent fncts.Kind foldRight
+ * @tsplus location "@fncts/base/typeclass/Foldable"
+ */
+export declare function foldRight<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>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>, 
+/** @tsplus auto */ F: Foldable<F>): Eval<B>;
+/**
+ * @tsplus fluent fncts.Kind foldMap
+ * @tsplus location "@fncts/base/typeclass/Foldable"
+ */
+export declare function foldMap<F extends HKT, K, Q, W, X, I, S, R, E, A, M>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (a: A) => M, 
+/** @tsplus auto */ F: Foldable<F>, 
+/** @tsplus auto */ M: Monoid<M>): M;

package/typeclass/FoldableWithIndex.d.ts

@@ -1,18 +1,13 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Eval } from "@fncts/base/control/Eval/definition";
-import type { FoldableMin } from "@fncts/base/typeclass/Foldable";
+import type { Foldable } from "@fncts/base/typeclass/Foldable";
 import type { Monoid } from "@fncts/base/typeclass/Monoid";
-import { Foldable } from "@fncts/base/typeclass/Foldable";
 /**
  * @tsplus type fncts.FoldableWithIndex
  */
-export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldable<F, FC> {
-    readonly foldLeftWithIndex_: foldLeftWithIndex_<F, FC>;
-    readonly foldLeftWithIndex: foldLeftWithIndex<F, FC>;
-    readonly foldRightWithIndex_: foldRightWithIndex_<F, FC>;
-    readonly foldRightWithIndex: foldRightWithIndex<F, FC>;
-    readonly foldMapWithIndex_: foldMapWithIndex_<F, FC>;
-    readonly foldMapWithIndex: foldMapWithIndex<F, FC>;
+export interface FoldableWithIndex<F extends HKT> extends Foldable<F> {
+    foldLeftWithIndex<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, b: B, f: (i: HKT.IndexFor<F, K>, b: B, a: A) => B): B;
+    foldRightWithIndex<K, Q, W, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, b: Eval<B>, f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
 }
 /**
  * @tsplus type fncts.FoldableWithIndexOps
@@ -20,30 +15,22 @@ export interface FoldableWithIndex<F extends HKT, FC = HKT.None> extends Foldabl
 export interface FoldableWithIndexOps {
 }
 export declare const FoldableWithIndex: FoldableWithIndexOps;
-export declare type FoldableWithIndexMin<F extends HKT, FC = HKT.None> = FoldableMin<F, FC> & {
-    readonly foldLeftWithIndex_: foldLeftWithIndex_<F, FC>;
-    readonly foldRightWithIndex_: foldRightWithIndex_<F, FC>;
-};
 /**
- * @tsplus static fncts.FoldableWithIndexOps __call
+ * @tsplus fluent fncts.Kind foldLeftWithIndex
  * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
  */
-export declare function mkFoldableWithIndex<F extends HKT, FC = HKT.None>(F: FoldableWithIndexMin<F, FC>): FoldableWithIndex<F, FC>;
-export interface foldLeftWithIndex_<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>, b: B, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, b: B, a: A) => B): B;
-}
-export interface foldLeftWithIndex<F extends HKT, FC = HKT.None> {
-    <K, A, B>(b: B, f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, b: B, a: A) => B): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => B;
-}
-export interface foldRightWithIndex_<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>, b: Eval<B>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A, b: Eval<B>) => Eval<B>): Eval<B>;
-}
-export interface foldRightWithIndex<F extends HKT, C = HKT.None> {
-    <K, A, B>(b: Eval<B>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A, b: Eval<B>) => Eval<B>): <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => Eval<B>;
-}
-export interface foldMapWithIndex_<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, Q, W, X, I, S, R, E, A>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>, f: (k: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => M) => M;
-}
-export interface foldMapWithIndex<F extends HKT, C = HKT.None> {
-    <M>(M: Monoid<M>): <K, A>(f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => M) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>) => M;
-}
+export declare function foldLeftWithIndex<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>, b: B, f: (i: HKT.IndexFor<F, K>, b: B, a: A) => B, 
+/** @tsplus auto */ F: FoldableWithIndex<F>): B;
+/**
+ * @tsplus fluent fncts.Kind foldRightWithIndex
+ * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
+ */
+export declare function foldRightWithIndex<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>, b: Eval<B>, f: (i: HKT.IndexFor<F, K>, a: A, b: Eval<B>) => Eval<B>, 
+/** @tsplus auto */ F: FoldableWithIndex<F>): Eval<B>;
+/**
+ * @tsplus fluent fncts.Kind foldMapWithIndex
+ * @tsplus location "@fncts/base/typeclass/FoldableWithIndex"
+ */
+export declare function foldMapWithIndex<F extends HKT, K, Q, W, X, I, S, R, E, A, M>(fa: HKT.Kind<F, K, Q, W, X, I, S, R, E, A>, f: (k: HKT.IndexFor<F, K>, a: A) => M, 
+/** @tsplus auto */ M: Monoid<M>, 
+/** @tsplus auto */ F: FoldableWithIndex<F>): M;

package/typeclass/Functor.d.ts

@@ -3,11 +3,8 @@ import { Lazy } from "@fncts/base/data/function/definition";
 /**
  * @tsplus type fncts.Functor
  */
-export interface Functor<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C> {
-    readonly map_: map_<F, C>;
-    readonly map: map<F, C>;
-    readonly as_: as_<F, C>;
-    readonly as: as<F, C>;
+export interface Functor<F extends HKT> extends HKT.Typeclass<F> {
+    map<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) => B): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
 }
 /**
  * @tsplus type fncts.FunctorOps
@@ -15,23 +12,15 @@ export interface Functor<F extends HKT, C = HKT.None> extends HKT.Typeclass<F, C
 export interface FunctorOps {
 }
 export declare const Functor: FunctorOps;
-export declare type FunctorMin<F extends HKT, C = HKT.None> = {
-    readonly map_: map_<F, C>;
-};
 /**
- * @tsplus static fncts.FunctorOps __call
+ * @tsplus fluent fncts.Kind map
  * @tsplus location "@fncts/base/typeclass/Functor"
  */
-export declare function mkFunctor<F extends HKT, C = HKT.None>(F: FunctorMin<F, C>): Functor<F, C>;
-export interface map_<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) => B): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface map<F extends HKT, C = HKT.None> {
-    <A, B>(f: (a: 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>;
-}
-export interface as_<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>, b: Lazy<B>): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, B>;
-}
-export interface as<F extends HKT, C = HKT.None> {
-    <B>(b: Lazy<B>): <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, E, B>;
-}
+export declare function map<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) => B, 
+/** @tsplus auto */ F: Functor<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;
+/**
+ * @tsplus fluent fncts.Kind as
+ * @tsplus location "@fncts/base/typeclass/Functor"
+ */
+export declare function as<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>, b: Lazy<B>, 
+/** @tsplus auto */ F: Functor<F>): HKT.Kind<F, K, Q, W, X, I, S, R, E, B>;

package/typeclass/FunctorWithIndex.d.ts

@@ -1,27 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Functor } from "@fncts/base/typeclass/Functor";
-export interface FunctorWithIndex<F extends HKT, C = HKT.None> extends Functor<F, C> {
-    readonly mapWithIndex_: mapWithIndex_<F, C>;
-    readonly mapWithIndex: mapWithIndex<F, C>;
+import type { Functor } from "@fncts/base/typeclass/Functor";
+export interface FunctorWithIndex<F extends HKT> extends Functor<F> {
+    mapWithIndex<K, W, Q, X, I, S, R, E, A, B>(fa: HKT.Kind<F, K, W, Q, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, K>, a: A) => B): HKT.Kind<F, K, W, Q, X, I, S, R, E, B>;
 }
-export declare type FunctorWithIndexMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & {
-    readonly mapWithIndex_: mapWithIndex_<F, FC>;
-};
 /**
  * @tsplus type fncts.FunctorWithIndexOps
  */
 export interface FunctorWithIndexOps {
 }
 export declare const FunctorWithIndex: FunctorWithIndexOps;
-/**
- * @tsplus static fncts.FunctorWithIndexOps __call
- * @tsplus location "@fncts/base/typeclass/FunctorWithIndex"
- */
-export declare function mkFunctorWithIndex<F extends HKT, C = HKT.None>(F: FunctorWithIndexMin<F, C>): FunctorWithIndex<F, C>;
-export interface mapWithIndex_<F extends HKT, C = HKT.None> {
-    <K, W, Q, X, I, S, R, E, A, B>(fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>, f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B): HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}
-export interface mapWithIndex<F extends HKT, C = HKT.None> {
-    <K, A, B>(f: (i: HKT.IndexFor<F, HKT.OrFix<C, "K", K>>, a: A) => B): <W, Q, X, I, S, R, E>(fa: HKT.Kind<F, C, K, W, Q, X, I, S, R, E, A>) => HKT.Kind<F, C, K, W, Q, X, I, S, R, E, B>;
-}