@fncts/base 0.0.2 → 0.0.5

package/typeclass/Traversable.d.ts

@@ -1,16 +1,13 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import type { Applicative, CompatibleApplicative } from "@fncts/base/typeclass/Applicative";
-import type { FoldableMin } from "@fncts/base/typeclass/Foldable";
-import type { FunctorMin } from "@fncts/base/typeclass/Functor";
-import { Foldable } from "@fncts/base/typeclass/Foldable";
-import { Functor } from "@fncts/base/typeclass/Functor";
+import type { Applicative } 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, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
-    readonly traverse_: traverse_<F, FC>;
-    readonly traverse: traverse<F, FC>;
-    readonly sequence: sequence<F, FC>;
+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>>;
 }
 /**
  * @tsplus type fncts.TraversableOps
@@ -18,54 +15,17 @@ export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC
 export interface TraversableOps {
 }
 export declare const Traversable: TraversableOps;
-export declare type TraversableMin<F extends HKT, FC = HKT.None> = FunctorMin<F, FC> & FoldableMin<F, FC> & {
-    readonly traverse_: traverse_<F, FC>;
-};
 /**
- * @tsplus static fncts.TraversableOps __call
+ * @tsplus fluent fncts.Kind traverse
  * @tsplus location "@fncts/base/typeclass/Traversable"
  */
-export declare function mkTraversable<F extends HKT, FC = HKT.None>(F: TraversableMin<F, FC>): Traversable<F, FC>;
-export interface traverse_<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>(ta: 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, 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 traverseSelf<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: (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 interface traverse<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, B>) => <KF, 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 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;
-}) => (G: Applicative<HKT.F<G>>) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>, f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>) => traverse_<F, FC>;
-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;
-}) => (G: Applicative<HKT.F<G>>) => (f: (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>>) => traverse<F, FC>;
-export interface sequence<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>(ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, 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, A>>;
-}
-export interface sequenceSelf<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: 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, XF, IF, SF, RF, EF, B>> : never;
-}
+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>>;
+/**
+ * @tsplus fluent fncts.Kind 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>>;

package/typeclass/TraversableWithIndex.d.ts

@@ -1,17 +1,14 @@
 import { HKT } from "@fncts/typelevel/HKT";
 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>>;
 }
 /**
  * @tsplus type fncts.TraversableWithIndexOps
@@ -19,46 +16,6 @@ export interface TraversableWithIndex<F extends HKT, FC = HKT.None> extends Func
 export interface TraversableWithIndexOps {
 }
 export declare const TraversableWithIndex: TraversableWithIndexOps;
-export declare 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
- * @tsplus location "@fncts/base/typeclass/TraversableWithIndex"
- */
-export declare function mkTraversableWithIndex<F extends HKT, FC = HKT.None>(F: TraversableWithIndexMin<F, FC>): TraversableWithIndex<F, FC>;
-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 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: 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 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;
-}) => (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 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>>;

package/typeclass/Witherable.d.ts

@@ -1,19 +1,17 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 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>;
+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>]>;
 }
 /**
  * @tsplus type fncts.WitherableOps
@@ -21,78 +19,20 @@ export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F,
 export interface WitherableOps {
 }
 export declare const Witherable: WitherableOps;
-export declare 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
+ * @tsplus fluent fncts.Kind wither
  * @tsplus location "@fncts/base/typeclass/Witherable"
  */
-export declare function mkWitherable<F extends HKT, FC = HKT.None>(F: WitherableMin<F, FC>): Witherable<F, FC>;
-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 declare 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 declare 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 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<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 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 declare 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 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 declare function filterAF_<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA_<F, CF>;
-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 declare function filterAF<F extends HKT, CF = HKT.None>(F: WitherableMin<F, CF>): filterA<F, CF>;
+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>>;

package/typeclass/WitherableWithIndex.d.ts

@@ -1,21 +1,18 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { Applicative } from "@fncts/base/typeclass/Applicative";
-import type { FilterableWithIndexMin } from "@fncts/base/typeclass/FilterableWithIndex";
-import type { TraversableWithIndexMin } from "@fncts/base/typeclass/TraversableWithIndex";
-import type { WitherableMin } from "@fncts/base/typeclass/Witherable";
-import { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
-import { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
-import { Witherable } from "@fncts/base/typeclass/Witherable";
+import type { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIndex";
+import type { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
+import type { Witherable } from "@fncts/base/typeclass/Witherable";
 /**
  * @tsplus type fncts.WitherableWithIndex
  */
-export interface WitherableWithIndex<F extends HKT, FC = HKT.None> extends FilterableWithIndex<F, FC>, TraversableWithIndex<F, FC>, Witherable<F, FC> {
-    readonly witherWithIndex_: witherWithIndex_<F, FC>;
-    readonly witherWithIndex: witherWithIndex<F, FC>;
-    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
-    readonly wiltWithIndex: wiltWithIndex<F, FC>;
+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>]>;
 }
 /**
  * @tsplus type fncts.WitherableWithIndexOps
@@ -23,92 +20,23 @@ export interface WitherableWithIndex<F extends HKT, FC = HKT.None> extends Filte
 export interface WitherableWithIndexOps {
 }
 export declare const WitherableWithIndex: WitherableWithIndexOps;
-export declare type WitherableWithIndexMin<F extends HKT, FC = HKT.None> = FilterableWithIndexMin<F, FC> & TraversableWithIndexMin<F, FC> & WitherableMin<F, FC> & {
-    readonly witherWithIndex_: witherWithIndex_<F, FC>;
-    readonly wiltWithIndex_: wiltWithIndex_<F, FC>;
-};
 /**
- * @tsplus static fncts.WitherableWithIndexOps __call
+ * @tsplus fluent fncts.Kind witherWithIndex
  * @tsplus location "@fncts/base/typeclass/WitherableWithIndex"
  */
-export declare function mkWitherableWithIndex<F extends HKT, FC = HKT.None>(F: WitherableWithIndexMin<F, FC>): WitherableWithIndex<F, FC>;
-export interface witherWithIndex<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, KF>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>) => <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 witherWithIndex_<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(F: 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: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", 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>>;
-}
-export interface witherWithIndexSelf<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>(F: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", 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>>;
-}
-export declare function mkWitherWithIndex<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;
-}) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>) => (wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>) => witherWithIndex<F, FC>;
-export declare function mkWitherWithIndex_<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;
-}) => (G: Applicative<HKT.F<G>>) => (wa: 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.FK1<G, Maybe<B>>) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>) => witherWithIndex_<F, FC>;
-export interface wiltWithIndex<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2, KF>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>) => <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, 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>]>;
-}
-export interface wiltWithIndex_<F extends HKT, FC = HKT.None> {
-    <G extends HKT, GC = HKT.None>(F: Applicative<G, GC>): <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A, B, B2>(wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>, f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", 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>]>;
-}
-export interface wiltWithIndexSelf<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>(F: Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B1, B2>(f: (k: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B1, 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, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>;
-}
-export declare function mkWiltWithIndex<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2, G>(_: {
-    A: A;
-    B: B;
-    B2: B2;
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-}) => (G: Applicative<HKT.F<G>>) => (f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B2>>) => (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, B2>]>) => wiltWithIndex<F, FC>;
-export declare function mkWiltWithIndex_<F extends HKT, FC = HKT.None>(): (i: <KF, QF, WF, XF, IF, SF, RF, EF, A, B1, B2, G>(_: {
-    G: G;
-    FK: KF;
-    FQ: QF;
-    FW: WF;
-    FX: XF;
-    FI: IF;
-    FS: SF;
-    FR: RF;
-    FE: EF;
-    A: A;
-    B: B1;
-    B2: B2;
-}) => (G: Applicative<HKT.F<G>>) => (wa: 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.FK1<G, Either<B1, B2>>) => HKT.FK1<G, readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B2>]>) => wiltWithIndex_<F, FC>;
-export interface FilterWithIndexAFn_<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: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, 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 declare function filterWithIndexAF_<F extends HKT, CF = HKT.None>(F: WitherableWithIndexMin<F, CF>): FilterWithIndexAFn_<F, CF>;
-export interface filterWithIndexA<F extends HKT, CF = HKT.None> {
-    <G extends HKT, CG = HKT.None>(G: Applicative<G, CG>): <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(p: (i: HKT.IndexFor<F, HKT.OrFix<CF, "K", KF>>, a: AF) => HKT.Kind<G, CG, KG, QG, WG, XG, IG, SG, RG, EG, boolean>) => <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 declare function filterWithIndexAF<F extends HKT, CF = HKT.None>(F: WitherableWithIndexMin<F, CF>): filterWithIndexA<F, CF>;
+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>>;
+/**
+ * @tsplus fluent fncts.Kind wiltWithIndex
+ * @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>>;

package/typeclass.d.ts

@@ -16,6 +16,7 @@ export * from "./typeclass/Foldable.js";
 export * from "./typeclass/FoldableWithIndex.js";
 export * from "./typeclass/Functor.js";
 export * from "./typeclass/FunctorWithIndex.js";
+export * from "./typeclass/Guard.js";
 export * from "./typeclass/Has.js";
 export * from "./typeclass/Hash.js";
 export * from "./typeclass/Hashable.js";

package/util/predicates.d.ts

@@ -18,6 +18,7 @@ export declare function isFunction(value: unknown): value is Function;
 export declare function isBoolean(value: unknown): value is boolean;
 export declare function isString(value: unknown): value is string;
 export declare function isNumber(value: unknown): value is number;
+export declare function isBigInt(value: unknown): value is bigint;
 export declare function isByte(n: unknown): n is number;
 export declare function isSymbol(value: unknown): value is symbol;
 export declare function isPlain(value: unknown): value is object;