@fncts/base 0.0.1 → 0.0.4

package/_src/typeclass/TraversableWithIndex.ts

@@ -1,21 +1,17 @@
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
-import type { FoldableWithIndexMin } from "@fncts/base/typeclass/FoldableWithIndex";
-import type { FunctorWithIndexMin } from "@fncts/base/typeclass/FunctorWithIndex";
-import type { TraversableMin } from "@fncts/base/typeclass/Traversable";
-
-import { FoldableWithIndex } from "@fncts/base/typeclass/FoldableWithIndex";
-import { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
-import { Traversable } from "@fncts/base/typeclass/Traversable";
+import type { FoldableWithIndex } from "@fncts/base/typeclass/FoldableWithIndex";
+import type { FunctorWithIndex } from "@fncts/base/typeclass/FunctorWithIndex";
+import type { Traversable } from "@fncts/base/typeclass/Traversable";
 
 /**
  * @tsplus type fncts.TraversableWithIndex
  */
-export interface TraversableWithIndex<F extends HKT, FC = HKT.None>
-  extends FunctorWithIndex<F, FC>,
-    FoldableWithIndex<F, FC>,
-    Traversable<F, FC> {
-  readonly traverseWithIndex_: traverseWithIndex_<F, FC>;
-  readonly traverseWithIndex: traverseWithIndex<F, FC>;
+export interface TraversableWithIndex<F extends HKT> extends FunctorWithIndex<F>, FoldableWithIndex<F>, Traversable<F> {
+  traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, KF, QF, WF, XF, IF, SF, RF, EF, A, B>(
+    ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 
 /**
@@ -25,118 +21,32 @@ export interface TraversableWithIndexOps {}
 
 export const TraversableWithIndex: TraversableWithIndexOps = {};
 
-export type TraversableWithIndexMin<F extends HKT, FC = HKT.None> = FunctorWithIndexMin<F, FC> &
-  FoldableWithIndexMin<F, FC> &
-  TraversableMin<F, FC> & {
-    readonly traverseWithIndex_: traverseWithIndex_<F, FC>;
-  };
-
-/**
- * @tsplus static fncts.TraversableWithIndexOps __call
- */
-export function mkTraversableWithIndex<F extends HKT, FC = HKT.None>(
-  F: TraversableWithIndexMin<F, FC>,
-): TraversableWithIndex<F, FC> {
-  return HKT.instance<TraversableWithIndex<F, FC>>({
-    ...FunctorWithIndex(F),
-    ...FoldableWithIndex(F),
-    ...Traversable(F),
-    traverseWithIndex_: F.traverseWithIndex_,
-    traverseWithIndex: (A) => {
-      const traverseWithIndex_ = F.traverseWithIndex_(A);
-      return (f) => (ta) => traverseWithIndex_(ta, f);
-    },
-  });
-}
-
-export interface traverseWithIndex_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    A,
-    B,
-  >(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface traverseWithIndex<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, KF, A, B>(
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => <QF, WF, XF, IF, SF, RF, EF>(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface traverseWithIndexSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    A: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export function mkTraverseWithIndex<F extends HKT, FC = HKT.None>(): (
-  i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    K: K;
-    Q: Q;
-    W: W;
-    X: X;
-    I: I;
-    S: S;
-    R: R;
-    E: E;
-  }) => (
-    A: Applicative<HKT.F<G>>,
-  ) => (
-    f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => HKT.FK1<G, B>,
-  ) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
-) => traverseWithIndex_<F, FC>;
-export function mkTraverseWithIndex() {
-  return (i: any) => i();
-}
-
-export function mkTraverseWithIndex_<F extends HKT, FC = HKT.None>(): (
-  i: <K, Q, W, X, I, S, R, E, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    K: HKT.OrFix<FC, "K", K>;
-    Q: Q;
-    W: W;
-    X: X;
-    I: I;
-    S: S;
-    R: R;
-    E: E;
-  }) => (
-    G: Applicative<HKT.F<G>>,
-  ) => (
-    ta: 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) => HKT.FK1<G, B>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
-) => traverseWithIndex_<F, FC>;
-export function mkTraverseWithIndex_() {
-  return (i: any) => i();
+export function traverseWithIndex<
+  F extends HKT,
+  G extends HKT,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  A,
+  B,
+>(
+  ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+  /** @tsplus auto */ F: TraversableWithIndex<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>> {
+  return F.traverseWithIndex(ta, f, G);
 }

package/_src/typeclass/Witherable.ts

@@ -1,163 +1,22 @@
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
-import type { FilterableMin } from "@fncts/base/typeclass/Filterable";
-import type { TraversableMin } from "@fncts/base/typeclass/Traversable";
-
-import { Filterable } from "@fncts/base/typeclass/Filterable";
-import { Traversable } from "@fncts/base/typeclass/Traversable";
+import type { Filterable } from "@fncts/base/typeclass/Filterable";
+import type { Traversable } from "@fncts/base/typeclass/Traversable";
 
 /**
  * @tsplus type fncts.Witherable
  */
-export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
-  readonly wilt_: wilt_<F, FC>;
-  readonly wilt: wilt<F, FC>;
-  readonly wither_: wither_<F, FC>;
-  readonly wither: wither<F, FC>;
-}
-
-/**
- * @tsplus type fncts.WitherableOps
- */
-export interface WitherableOps {}
-
-export const Witherable: WitherableOps = {};
-
-export type WitherableMin<F extends HKT, FC = HKT.None> = FilterableMin<F, FC> &
-  TraversableMin<F, FC> & {
-    readonly wilt_: wilt_<F, FC>;
-    readonly wither_: wither_<F, FC>;
-  };
-
-/**
- * @tsplus static fncts.WitherableOps __call
- */
-export function mkWitherable<F extends HKT, FC = HKT.None>(F: WitherableMin<F, FC>): Witherable<F, FC> {
-  return HKT.instance({
-    ...Filterable(F),
-    ...Traversable(F),
-    wilt_: F.wilt_,
-    wilt: <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>) => {
-      const wilt_ = F.wilt_(A);
-      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B1>(
-          f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-        ) =>
-        <K, Q, W, X, I, S, R, E>(wa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) =>
-          wilt_(wa, f);
-    },
-    wither_: F.wither_,
-    wither: <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>) => {
-      const wither_ = F.wither_(A);
-      return <KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-          f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-        ) =>
-        <K, Q, W, X, I, S, R, E>(wa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) =>
-          wither_(wa, (a) => f(a));
-    },
-  });
-}
-
-export interface wither<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface wither_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, GC = HKT.None>(A: Applicative<G, GC>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    A,
-    B,
-  >(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export interface witherSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    A: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-}
-
-export function mkWither<F extends HKT, FC = HKT.None>(): (
-  i: <FK, FQ, FW, FX, FI, FS, FR, FE, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    FK: FK;
-    FQ: FQ;
-    FW: FW;
-    FX: FX;
-    FI: FI;
-    FS: FS;
-    FR: FR;
-    FE: FE;
-  }) => (
-    A: Applicative<HKT.F<G>>,
-  ) => (
-    f: (a: A) => HKT.FK1<G, Maybe<B>>,
-  ) => (
-    wa: HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, A>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, B>>,
-) => wither<F, FC>;
-export function mkWither() {
-  return (i: any) => i();
-}
-
-export function mkWither_<F extends HKT, FC = HKT.None>(): (
-  i: <FK, FQ, FW, FX, FI, FS, FR, FE, A, B, G>(_: {
-    A: A;
-    B: B;
-    G: G;
-    FK: FK;
-    FQ: FQ;
-    FW: FW;
-    FX: FX;
-    FI: FI;
-    FS: FS;
-    FR: FR;
-    FE: FE;
-  }) => (
-    A: Applicative<HKT.F<G>>,
-  ) => (
-    wa: HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, A>,
-    f: (a: A) => HKT.FK1<G, Maybe<B>>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, FK, FQ, FW, FX, FI, FS, FR, FE, B>>,
-) => wither_<F, FC>;
-export function mkWither_() {
-  return (i: any) => i();
-}
-
-export interface wilt<F extends HKT, FC = HKT.None> {
-  <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B1>(
-    f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.Kind<
+export interface Witherable<F extends HKT> extends Filterable<F>, Traversable<F> {
+  wither<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
+    wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+  wilt<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(
+    wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+    f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
+    /** @tsplus auto */ G: Applicative<G>,
+  ): HKT.Kind<
     G,
-    CG,
     KG,
     QG,
     WG,
@@ -166,138 +25,120 @@ export interface wilt<F extends HKT, FC = HKT.None> {
     SG,
     RG,
     EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
+    readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
   >;
 }
 
-export interface wilt_<F extends HKT, FC = HKT.None> {
-  <G extends HKT, CG = HKT.None>(A: Applicative<G, CG>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    B1,
-    A,
-    B,
-  >(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-    f: (a: A) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-  ) => HKT.Kind<
-    G,
-    CG,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
-  >;
-}
-
-export interface wiltSelf<F extends HKT, FC = HKT.None> {
-  <KF, QF, WF, XF, IF, SF, RF, EF, A>(self: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>): <
-    G extends HKT,
-    GC = HKT.None,
-  >(
-    A: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(
-    f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
-  ) => HKT.Kind<
-    G,
-    GC,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
-  >;
-}
-
-export function mkWilt<F extends HKT, FC = HKT.None>(): (
-  i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B1, G>(_: {
-    A: A;
-    B: B;
-    B1: B1;
-    G: G;
-    KF: KF;
-    QF: QF;
-    WF: WF;
-    XF: XF;
-    IF: IF;
-    SF: SF;
-    RF: RF;
-    EF: EF;
-  }) => (
-    A: Applicative<HKT.F<G>>,
-  ) => (
-    f: (a: A) => HKT.FK1<G, Either<B, B1>>,
-  ) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => HKT.FK1<
-    G,
-    readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
-  >,
-) => wilt<F, FC>;
-export function mkWilt() {
-  return (i: any) => i();
-}
+/**
+ * @tsplus type fncts.WitherableOps
+ */
+export interface WitherableOps {}
 
-export interface filterA_<F extends HKT, CF = HKT.None> {
-  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <
-    KF,
-    QF,
-    WF,
-    XF,
-    IF,
-    SF,
-    RF,
-    EF,
-    AF,
-    KG,
-    QG,
-    WG,
-    XG,
-    IG,
-    SG,
-    RG,
-    EG,
-  >(
-    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-    p: (a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
-  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
-}
+export const Witherable: WitherableOps = {};
 
-export function filterAF_<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA_<F, CF> {
-  return (G) => (fa, p) => F.wither_(G)(fa, (a) => G.map_(p(a), (bb) => (bb ? Just(a) : Nothing())));
+/**
+ * @tsplus fluent fncts.Kind wither
+ */
+export function wither<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  A,
+  B,
+>(
+  wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
+  /** @tsplus auto */ F: Witherable<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>> {
+  return F.wither(wa, f);
 }
 
-export interface filterA<F extends HKT, CF = HKT.None> {
-  <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <AF, KG, QG, WG, XG, IG, SG, RG, EG>(
-    p: (a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
-  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
-    fa: HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-  ) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, CF, KF, QF, WF, XF, IF, SF, RF, EF, AF>>;
+export function wilt<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  B1,
+  A,
+  B,
+>(
+  wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
+  /** @tsplus auto */ F: Witherable<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<
+  G,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+  readonly [HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
+> {
+  return F.wilt(wa, f);
 }
 
-export function filterAF<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA<F, CF> {
-  return (G) => (p) => (fa) => filterAF_(F)(G)(fa, p);
+/**
+ * @tsplus fluent fncts.Kind filterA
+ */
+export function filterA<
+  F extends HKT,
+  G extends HKT,
+  KF,
+  QF,
+  WF,
+  XF,
+  IF,
+  SF,
+  RF,
+  EF,
+  AF,
+  KG,
+  QG,
+  WG,
+  XG,
+  IG,
+  SG,
+  RG,
+  EG,
+>(
+  fa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
+  p: (a: AF) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+  /** @tsplus auto */ F: Witherable<F>,
+  /** @tsplus auto */ G: Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
+  return fa.wither((a) => p(a).map((bb) => (bb ? Just(a) : Nothing()), G));
 }