@fncts/base 0.0.12 → 0.0.15

package/_src/typeclass/Semimonoidal.ts

@@ -1,29 +1,31 @@
-export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
-  zip<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>,
+export interface Semimonoidal<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  zip: <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,
-      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>,
+      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<
+  ) => 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]>,
-    readonly [A, B]
+    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]>,
+    Zipped.Make<A, B>
   >;
 }
 
@@ -33,36 +35,3 @@ export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
 export interface SemimonoidalOps {}
 
 export const Semimonoidal: SemimonoidalOps = {};
-
-/**
- * @tsplus fluent fncts.Kind zip
- */
-export function zip<F extends HKT, C, 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: Semimonoidal<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]>,
-  readonly [A, B]
-> {
-  return F.zip(fa, fb);
-}

package/_src/typeclass/Showable/show.ts

@@ -72,7 +72,7 @@ export interface ShowOptions {
 
 export class ShowContext extends CaseClass<ShowContextArgs> {}
 
-export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export type ShowComputation = ShowComputationZ<string>;
 export type ShowComputationChunk = ShowComputationZ<Conc<string>>;
 
@@ -240,7 +240,7 @@ function getInspectionInfo(context: ShowContext, value: object, typedArray?: str
 
   if (value[Symbol.iterator as keyof typeof value] || constructor === null) {
     noIterator = false;
-    if (Conc.isConc(value)) {
+    if (Conc.is(value)) {
       braces = [`Chunk (${(value as Conc<unknown>).length}) [`, "]"];
       if ((value as Conc<unknown>).length == 0) {
         return inspectionEarlyReturn(`${braces[0]}]`);
@@ -400,9 +400,9 @@ function showRaw(value: object, typedArray?: string): ShowComputation {
               case "InspectionInfo": {
                 base = Z.succeedNow(info.base);
                 keys = Conc.from(info.keys)
-                  .traverse((key) => showProperty(value, key, info.extrasType), Z.Applicative)
+                  .traverse(Z.Applicative)((key) => showProperty(value, key, info.extrasType))
                   .crossWith(
-                    info.protoProps.traverse((key) => showProperty(value, key, PROTO_TYPE), Z.Applicative),
+                    info.protoProps.traverse(Z.Applicative)((key) => showProperty(value, key, PROTO_TYPE)),
                     (k1, k2) => k1.concat(k2),
                   );
                 indices    = info.formatter(value);
@@ -537,16 +537,15 @@ function removeColors(str: string): string {
 
 function showSet(value: Set<unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
-    .apSecond((value as Iterable<unknown>).traverseToConc(_show, Z.Applicative))
+    .apSecond((value as Iterable<unknown>).traverseToConc(Z.Applicative)(_show))
     .apFirst(Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel - 2 })));
 }
 
 function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
     .apSecond(
-      (value as Iterable<[unknown, unknown]>).traverseToConc(
-        ([k, v]) => _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
-        Z.Applicative,
+      (value as Iterable<[unknown, unknown]>).traverseToConc(Z.Applicative)(([k, v]) =>
+        _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
       ),
     )
     .apFirst(
@@ -578,9 +577,8 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
           .apSecond(
             Z.succeedNow(output).flatMap((output) =>
               Conc("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer")
-                .traverse(
-                  (key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`),
-                  Z.Applicative,
+                .traverse(Z.Applicative)((key) =>
+                  _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`),
                 )
                 .map((shownKeys) => output.concat(shownKeys)),
             ),
@@ -699,7 +697,7 @@ function showChunk(value: Conc<unknown>): ShowComputationChunk {
     return tuple(remaining, chunk);
   }).flatMap(([remaining, chunk]) =>
     chunk
-      .traverse(_show, Z.Applicative)
+      .traverse(Z.Applicative)(_show)
       .map((chunk) => (remaining > 0 ? chunk.append(`... ${remaining} more item${pluralize(remaining)}`) : chunk)),
   );
 }

package/_src/typeclass/Traversable.ts

@@ -1,4 +1,4 @@
-import type { Applicative } from "@fncts/base/typeclass/Applicative";
+import type { Applicative, CompatibleApplicative } from "@fncts/base/typeclass/Applicative";
 import type { Foldable } from "@fncts/base/typeclass/Foldable";
 import type { Functor } from "@fncts/base/typeclass/Functor";
 
@@ -7,12 +7,14 @@ import { identity } from "@fncts/base/data/function";
 /**
  * @tsplus type fncts.Traversable
  */
-export interface Traversable<F extends HKT> extends Functor<F>, Foldable<F> {
-  traverse<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
-    ta: 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, 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>>;
+export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
+  traverse: <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>(
+    G: 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, 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>>;
 }
 
 /**
@@ -23,65 +25,45 @@ export interface TraversableOps {}
 export const Traversable: TraversableOps = {};
 
 /**
- * @tsplus fluent fncts.Kind traverse
+ * @tsplus static fncts.TraversableOps makeTraverse
  */
-export function traverse<
-  F extends HKT,
-  G extends HKT,
-  KF,
-  QF,
-  WF,
-  XF,
-  IF,
-  SF,
-  RF,
-  EF,
-  KG,
-  QG,
-  WG,
-  XG,
-  IG,
-  SG,
-  RG,
-  EG,
-  A,
-  B,
->(
-  ta: 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, B>,
-  /** @tsplus auto */ F: Traversable<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.traverse(ta, f, G);
+export function mkTraverse_<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;
+  }) => (
+    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
+) => Traversable<F, FC>["traverse"];
+export function mkTraverse_() {
+  return (i: any) => i();
 }
 
 /**
- * @tsplus fluent fncts.Kind sequence
+ * @tsplus static fncts.TraversableOps sequence
  */
-export function sequence<
-  F extends HKT,
-  G extends HKT,
-  KF,
-  QF,
-  WF,
-  XF,
-  IF,
-  SF,
-  RF,
-  EF,
-  KG,
-  QG,
-  WG,
-  XG,
-  IG,
-  SG,
-  RG,
-  EG,
-  A,
->(
-  ta: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, A>>,
-  /** @tsplus auto */ F: Traversable<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, A>> {
-  return ta.traverse(identity);
+export function sequence<F extends HKT, FC>(
+  F: Traversable<F, FC>,
+): <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>(
+  G: CompatibleApplicative<G, GC, A>,
+) => [A] extends [
+  HKT.Kind<G, GC, infer KG, infer QG, infer WG, infer XG, infer IG, infer SG, infer RG, infer EG, infer B>,
+]
+  ? HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XG, IF, SF, RF, EF, B>>
+  : never {
+  // @ts-expect-error
+  return (ta) => (G) => F.traverse(ta)(G)(identity);
 }

package/_src/typeclass/TraversableWithIndex.ts

@@ -6,12 +6,17 @@ import type { Traversable } from "@fncts/base/typeclass/Traversable";
 /**
  * @tsplus type fncts.TraversableWithIndex
  */
-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>>;
+export interface TraversableWithIndex<F extends HKT, FC = HKT.None>
+  extends FunctorWithIndex<F, FC>,
+    FoldableWithIndex<F, FC>,
+    Traversable<F, FC> {
+  traverseWithIndex: <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>(
+    G: Applicative<G, GC>,
+  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+    f: (i: HKT.IndexFor<F, 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>>;
 }
 
 /**
@@ -21,32 +26,30 @@ export interface TraversableWithIndexOps {}
 
 export const TraversableWithIndex: TraversableWithIndexOps = {};
 
-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);
+/**
+ * @tsplus static fncts.TraversableWithIndexOps makeTraverseWithIndex
+ */
+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;
+  }) => (
+    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
+  ) => (
+    G: Applicative<HKT.F<G>>,
+  ) => (
+    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>>,
+) => TraversableWithIndex<F, FC>["traverseWithIndex"];
+export function mkTraverseWithIndex_() {
+  return (i: any) => i();
 }

package/_src/typeclass/Witherable.ts

@@ -5,18 +5,23 @@ import type { Traversable } from "@fncts/base/typeclass/Traversable";
 /**
  * @tsplus type fncts.Witherable
  */
-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<
+export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
+  wither: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => <G extends HKT, GC = HKT.None>(
+    G: 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>>;
+  wilt: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
+  ) => <G extends HKT, GC = HKT.None>(
+    G: 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,
@@ -25,7 +30,7 @@ export interface Witherable<F extends HKT> extends Filterable<F>, Traversable<F>
     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>]
+    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>]
   >;
 }
 
@@ -37,108 +42,16 @@ export interface WitherableOps {}
 export const Witherable: WitherableOps = {};
 
 /**
- * @tsplus fluent fncts.Kind wither
+ * @tsplus static fncts.WitherableOps filterA
  */
-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 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);
-}
-
-/**
- * @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));
+export function filterA<F extends HKT, FC = HKT.None>(
+  F: Witherable<F, FC>,
+): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(
+  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
+) => <G extends HKT, GC = HKT.None>(
+  G: Applicative<G, GC>,
+) => <KG, QG, WG, XG, IG, SG, RG, EG>(
+  p: (a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
+  return (fa) => (G) => (p) => F.wither(fa)(G)((a) => G.map(p(a), (bb) => (bb ? Just(a) : Nothing())));
 }