@fncts/base 0.0.3 → 0.0.6

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;