@fncts/base 0.0.12 → 0.0.13

package/typeclass/Semimonoidal.d.ts

@@ -1,6 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
-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>, 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>): 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]>;
+import { Zipped } from "@fncts/base/data/Zipped";
+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, 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]>, Zipped.Make<A, B>>;
 }
 /**
  * @tsplus type fncts.SemimonoidalOps
@@ -8,9 +9,3 @@ export interface Semimonoidal<F extends HKT> extends HKT.Typeclass<F> {
 export interface SemimonoidalOps {
 }
 export declare const Semimonoidal: SemimonoidalOps;
-/**
- * @tsplus fluent fncts.Kind zip
- * @tsplus location "@fncts/base/typeclass/Semimonoidal"
- */
-export declare 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]>;

package/typeclass/Traversable.d.ts

@@ -1,13 +1,12 @@
 import { HKT } from "@fncts/typelevel/HKT";
-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";
 /**
  * @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>>;
 }
 /**
  * @tsplus type fncts.TraversableOps
@@ -16,16 +15,26 @@ export interface TraversableOps {
 }
 export declare const Traversable: TraversableOps;
 /**
- * @tsplus fluent fncts.Kind traverse
+ * @tsplus static fncts.TraversableOps makeTraverse
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare 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>>;
+export declare 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"];
 /**
- * @tsplus fluent fncts.Kind sequence
+ * @tsplus static fncts.TraversableOps sequence
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare 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>>;
+export declare 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;

package/typeclass/TraversableWithIndex.d.ts

@@ -6,9 +6,8 @@ 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>>;
 }
 /**
  * @tsplus type fncts.TraversableWithIndexOps
@@ -16,6 +15,20 @@ export interface TraversableWithIndex<F extends HKT> extends FunctorWithIndex<F>
 export interface TraversableWithIndexOps {
 }
 export declare const TraversableWithIndex: TraversableWithIndexOps;
-export declare 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>>;
+/**
+ * @tsplus static fncts.TraversableWithIndexOps makeTraverseWithIndex
+ * @tsplus location "@fncts/base/typeclass/TraversableWithIndex"
+ */
+export declare 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"];

package/typeclass/Witherable.d.ts

@@ -7,11 +7,9 @@ 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<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>]>;
+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, 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>]>;
 }
 /**
  * @tsplus type fncts.WitherableOps
@@ -20,19 +18,7 @@ export interface WitherableOps {
 }
 export declare const Witherable: WitherableOps;
 /**
- * @tsplus fluent fncts.Kind wither
+ * @tsplus static fncts.WitherableOps filterA
  * @tsplus location "@fncts/base/typeclass/Witherable"
  */
-export declare 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>>;
-export declare 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>]>;
-/**
- * @tsplus fluent fncts.Kind filterA
- * @tsplus location "@fncts/base/typeclass/Witherable"
- */
-export declare 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>>;
+export declare 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>>;

package/typeclass/WitherableWithIndex.d.ts

@@ -8,11 +8,9 @@ import type { Witherable } from "@fncts/base/typeclass/Witherable";
 /**
  * @tsplus type fncts.WitherableWithIndex
  */
-export interface WitherableWithIndex<F extends HKT> extends FilterableWithIndex<F>, TraversableWithIndex<F>, Witherable<F> {
-    witherWithIndex<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: (k: HKT.IndexFor<F, KF>, 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>>;
-    wiltWithIndex<G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>, 
-    /** @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, B2>]>;
+export interface WitherableWithIndex<F extends HKT, FC = HKT.None> extends FilterableWithIndex<F, FC>, TraversableWithIndex<F, FC>, Witherable<F, FC> {
+    witherWithIndex: <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: (k: HKT.IndexFor<F, KF>, 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>>;
+    wiltWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2>(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, B2>(f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>) => 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, B2>]>;
 }
 /**
  * @tsplus type fncts.WitherableWithIndexOps
@@ -21,22 +19,38 @@ export interface WitherableWithIndexOps {
 }
 export declare const WitherableWithIndex: WitherableWithIndexOps;
 /**
- * @tsplus fluent fncts.Kind witherWithIndex
+ * @tsplus static fncts.WitherableWithIndexOps makeWitherWithIndex
  * @tsplus location "@fncts/base/typeclass/WitherableWithIndex"
  */
-export declare function witherWithIndex<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: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>, 
-/** @tsplus auto */
-F: WitherableWithIndex<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>>;
+export declare function makeWitherWithIndex<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, G>(_: {
+    A: A;
+    B: B;
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+}) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>) => WitherableWithIndex<F, FC>["witherWithIndex"];
 /**
- * @tsplus fluent fncts.Kind wiltWithIndex
+ * @tsplus static fncts.WitherableWithIndexOps makeWiltWithIndex
  * @tsplus location "@fncts/base/typeclass/WitherableWithIndex"
  */
-export declare function wiltWithIndex<F extends HKT, G extends HKT, KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2>(wa: HKT.Kind<F, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>, 
-/** @tsplus auto */
-F: WitherableWithIndex<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, B2>]>;
-export declare function filterWithIndexA<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: (i: HKT.IndexFor<F, KF>, a: AF) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, boolean>, 
-/** @tsplus auto */ F: WitherableWithIndex<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>>;
+export declare function makeWiltWithIndex<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B1, G>(_: {
+    G: G;
+    FK: KF;
+    FQ: QF;
+    FW: WF;
+    FX: XF;
+    FI: IF;
+    FS: SF;
+    FR: RF;
+    FE: EF;
+    A: A;
+    B: B;
+    B1: B1;
+}) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B1>>) => 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>]>) => WitherableWithIndex<F, FC>["wiltWithIndex"];
+export declare function filterWithIndexA<F extends HKT, FC = HKT.None>(F: WitherableWithIndex<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: (i: HKT.IndexFor<F, KF>, 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>>;

package/types/extractions.d.ts

@@ -7,6 +7,6 @@ export declare type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] exte
 export declare type _W<A> = ExtractCovariantPhantom<A, "_W">;
 export declare type _S1<A> = ExtractContravariantPhantom<A, "_S1">;
 export declare type _S2<A> = ExtractCovariantPhantom<A, "_S2">;
-export declare type _R<A> = ExtractContravariantPhantom<A, "_R">;
+export declare type _R<A> = ExtractCovariantPhantom<A, "_R">;
 export declare type _E<A> = ExtractCovariantPhantom<A, "_E">;
 export declare type _A<A> = ExtractCovariantPhantom<A, "_A">;