@fncts/base 0.0.1 → 0.0.4

package/_src/typeclass/Filterable.ts

@@ -1,19 +1,33 @@
-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>];
 }
 
 /**
@@ -23,117 +37,56 @@ export interface FilterableOps {}
 
 export const Filterable: FilterableOps = {};
 
-export 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
  */
-export function mkFilterable<F extends HKT, FC = HKT.None>(F: FilterableMin<F, FC>): Filterable<F, FC>;
-export function mkFilterable<F>(F: FilterableMin<HKT.F<F>>): Filterable<HKT.F<F>> {
-  return HKT.instance<Filterable<HKT.F<F>>>({
-    ...Functor(F),
-    filter_: F.filter_,
-    filter:
-      <A>(p: Predicate<A>) =>
-      <K, Q, W, X, I, S, R, E>(fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>) =>
-        F.filter_(fa, p),
-    partition_: F.partition_,
-    partition:
-      <A>(p: Predicate<A>) =>
-      <K, Q, W, X, I, S, R, E>(fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>) =>
-        F.partition_(fa, p),
-    filterMap_: F.filterMap_,
-    filterMap: (f) => (fa) => F.filterMap_(fa, f),
-    partitionMap_: F.partitionMap_,
-    partitionMap: (f) => (fa) => F.partitionMap_(fa, f),
-  });
-}
-
-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 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>;
+export function filter<F extends HKT, 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>,
+  /** @tsplus auto */ F: Filterable<F>,
+): HKT.Kind<F, K, Q, W, X, I, S, R, E, A> {
+  return F.filter(fa, predicate);
 }
 
-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>];
+/**
+ * @tsplus fluent fncts.Kind filterMap
+ */
+export 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> {
+  return F.filterMap(fa, f);
 }
 
-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>];
+/**
+ * @tsplus fluent fncts.Kind partition
+ */
+export 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>];
+export function partition<F extends HKT, 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>,
+  /** @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, A>] {
+  return F.partition(fa, predicate);
 }
 
-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>];
+/**
+ * @tsplus fluent fncts.Kind partitionMap
+ */
+export 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>] {
+  return F.partitionMap(fa, f);
 }

package/_src/typeclass/FilterableWithIndex.ts

@@ -1,21 +1,34 @@
-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>];
 }
 
 /**
@@ -24,120 +37,3 @@ export interface FilterableWithIndex<F extends HKT, FC = HKT.None> extends Funct
 export interface FilterableWithIndexOps {}
 
 export const FilterableWithIndex: FilterableWithIndexOps = {};
-
-export 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
- */
-export function mkFilterableWithIndex<F extends HKT, FC = HKT.None>(
-  F: FilterableWithIndexMin<F, FC>,
-): FilterableWithIndex<F, FC>;
-export function mkFilterableWithIndex<F>(F: FilterableWithIndexMin<HKT.F<F>>): FilterableWithIndex<HKT.F<F>> {
-  return HKT.instance<FilterableWithIndex<HKT.F<F>>>({
-    ...FunctorWithIndex(F),
-    ...Filterable(F),
-    filterWithIndex_: F.filterWithIndex_,
-    filterWithIndex:
-      <K, A>(f: PredicateWithIndex<K, A>) =>
-      <Q, W, X, I, S, R, E>(fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>) =>
-        F.filterWithIndex_(fa, f),
-    partitionWithIndex_: F.partitionWithIndex_,
-    partitionWithIndex:
-      <K, A>(f: PredicateWithIndex<K, A>) =>
-      <Q, W, X, I, S, R, E>(fa: HKT.FK<F, K, Q, W, X, I, S, R, E, A>) =>
-        F.partitionWithIndex_(fa, f),
-    filterMapWithIndex_: F.filterMapWithIndex_,
-    filterMapWithIndex: (f) => (fa) => F.filterMapWithIndex_(fa, f),
-    partitionMapWithIndex_: F.partitionMapWithIndex_,
-    partitionMapWithIndex: (f) => (fa) => F.partitionMapWithIndex_(fa, f),
-  });
-}
-
-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/_src/typeclass/Foldable.ts

@@ -3,13 +3,13 @@ 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>;
 }
 
 /**
@@ -19,55 +19,38 @@ export interface FoldableOps {}
 
 export const Foldable: FoldableOps = {};
 
-export 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
  */
-export function mkFoldable<F extends HKT, FC = HKT.None>(F: FoldableMin<F, FC>): Foldable<F, FC> {
-  const foldMap_: foldMap_<F, FC> = (M) => (fa, f) => F.foldLeft_(fa, M.nat, (b, a) => M.combine_(b, f(a)));
-
-  return HKT.instance<Foldable<F, FC>>({
-    foldLeft_: F.foldLeft_,
-    foldLeft: (b, f) => (fa) => F.foldLeft_(fa, b, f),
-    foldRight_: F.foldRight_,
-    foldRight: (b, f) => (fa) => F.foldRight_(fa, b, f),
-    foldMap_,
-    foldMap: (M) => (f) => (fa) => foldMap_(M)(fa, f),
-  });
-}
-
-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 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 {
+  return F.foldLeft(fa, b, f);
 }
 
-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;
+/**
+ * @tsplus fluent fncts.Kind foldRight
+ */
+export 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> {
+  return F.foldRight(fa, b, f);
 }
 
-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;
+/**
+ * @tsplus fluent fncts.Kind foldMap
+ */
+export 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 {
+  return fa.foldLeft(M.nat, (b, a) => M.combine(b, f(a)));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -1,18 +1,20 @@
-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>;
 }
 
 /**
@@ -22,75 +24,38 @@ export interface FoldableWithIndexOps {}
 
 export const FoldableWithIndex: FoldableWithIndexOps = {};
 
-export 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
  */
-export function mkFoldableWithIndex<F extends HKT, FC = HKT.None>(
-  F: FoldableWithIndexMin<F, FC>,
-): FoldableWithIndex<F, FC> {
-  const foldMapWithIndex_: foldMapWithIndex_<F, FC> = (M) => (fa, f) =>
-    F.foldLeftWithIndex_(fa, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
-  return HKT.instance<FoldableWithIndex<F, FC>>({
-    ...Foldable(F),
-    foldLeftWithIndex_: F.foldLeftWithIndex_,
-    foldLeftWithIndex: (b, f) => (fa) => F.foldLeftWithIndex_(fa, b, f),
-    foldRightWithIndex_: F.foldRightWithIndex_,
-    foldRightWithIndex: (b, f) => (fa) => F.foldRightWithIndex_(fa, b, f),
-    foldMapWithIndex_,
-    foldMapWithIndex: (M) => (f) => (fa) => foldMapWithIndex_(M)(fa, f),
-  });
-}
-
-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 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 {
+  return F.foldLeftWithIndex(fa, b, f);
 }
 
-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;
+/**
+ * @tsplus fluent fncts.Kind foldRightWithIndex
+ */
+export 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> {
+  return F.foldRightWithIndex(fa, b, f);
 }
 
-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;
+/**
+ * @tsplus fluent fncts.Kind foldMapWithIndex
+ */
+export 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 {
+  return fa.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }