@fncts/base 0.0.12 → 0.0.13

package/_src/typeclass/WitherableWithIndex.ts

@@ -6,21 +6,26 @@ 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<
+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,
@@ -29,7 +34,7 @@ export interface WitherableWithIndex<F extends HKT>
     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>]
+    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>]
   >;
 }
 
@@ -41,111 +46,73 @@ export interface WitherableWithIndexOps {}
 export const WitherableWithIndex: WitherableWithIndexOps = {};
 
 /**
- * @tsplus fluent fncts.Kind witherWithIndex
+ * @tsplus static fncts.WitherableWithIndexOps makeWitherWithIndex
  */
-export 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>> {
-  return F.witherWithIndex(wa, f);
+export 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"];
+export function makeWitherWithIndex() {
+  return (i: any) => i();
 }
 
 /**
- * @tsplus fluent fncts.Kind wiltWithIndex
+ * @tsplus static fncts.WitherableWithIndexOps makeWiltWithIndex
  */
-export 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>]
-> {
-  return F.wiltWithIndex(wa, f);
+export 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 function makeWiltWithIndex() {
+  return (i: any) => i();
 }
 
-export 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>> {
-  return fa.witherWithIndex((i, a) => p(i, a).map((bb) => (bb ? Just(a) : Nothing()), G));
+export 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>> {
+  return (fa) => (G) => (p) => F.witherWithIndex(fa)(G)((i, a) => G.map(p(i, a), (bb) => (bb ? Just(a) : Nothing())));
 }

package/_src/types/extractions.ts

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

package/collection/Iterable/api/traverseConc.d.ts

@@ -2,14 +2,12 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.Iterable traverseToConcWithIndex
+ * @tsplus getter fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConcWithIndex_<G extends HKT, K, Q, W, X, I, S, R, E, A, B>(ta: Iterable<A>, f: (i: number, a: A) => HKT.Kind<G, K, Q, W, X, I, S, R, E, B>, 
-/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, K, Q, W, X, I, S, R, E, Conc<B>>;
+export declare function traverseToConcWithIndex_<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
 /**
- * @tsplus fluent fncts.Iterable traverseToConc
+ * @tsplus getter fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function traverseToConc_<G extends HKT, K, Q, W, X, I, S, R, E, A, B>(ta: Iterable<A>, f: (a: A) => HKT.Kind<G, K, Q, W, X, I, S, R, E, B>, 
-/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, K, Q, W, X, I, S, R, E, Conc<B>>;
+export declare function traverseToConc_<A>(ta: Iterable<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;

package/collection/compat/Record/instances.d.ts

@@ -1,6 +1,18 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder";
 import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard<_> 15
+ * @tsplus location "@fncts/base/collection/compat/Record/instances"
+ */
+export declare function deriveDictionaryGuard<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Guard<A[keyof A]>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard<_> 15
+ * @tsplus location "@fncts/base/collection/compat/Record/instances"
+ */
+export declare function deriveGuard<A extends Record<string, any>>(...[key, value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [key: Guard<keyof A>, value: Guard<A[keyof A]>, requiredKeys: {
+    [k in keyof A]: 0;
+}] : never): Guard<A>;
 /**
  * @tsplus derive fncts.Decoder<_> 15
  * @tsplus location "@fncts/base/collection/compat/Record/instances"

package/collection/immutable/Conc/api.d.ts

@@ -4,11 +4,10 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
-import { HKT } from "@fncts/typelevel/HKT";
 import { Byte } from "@fncts/base/data/Byte";
 import type { ConcF } from "@fncts/base/collection/immutable/Conc/definition";
 import type { Eq } from "@fncts/base/typeclass";
-import type * as P from "@fncts/base/typeclass";
+import * as P from "@fncts/base/typeclass";
 /**
  * @tsplus fluent fncts.Conc align
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
@@ -295,16 +294,15 @@ export declare function take_<A>(self: Conc<A>, n: number): Conc<A>;
  */
 export declare function takeWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A>;
 /**
- * @tsplus fluent fncts.Conc traverse
+ * @tsplus getter fncts.Conc traverse
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
 export declare const traverse: P.Traversable<ConcF>["traverse"];
 /**
- * @tsplus fluent fncts.Conc traverseWithIndex
+ * @tsplus getter fncts.Conc traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(self: Conc<A>, f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>, 
-/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Conc<B>>;
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/Conc/definition").Conc<B>>;
 /**
  * @tsplus getter fncts.Conc toBuffer
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

package/collection/immutable/Conc/definition.d.ts

@@ -1,6 +1,6 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { HKT } from "@fncts/typelevel/HKT";
 import { isByte } from "@fncts/base/util/predicates";
 import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 import { unsafeCoerce } from "@fncts/base/data/function/api";
@@ -19,17 +19,19 @@ export declare const enum ConcTag {
     Chunk = "Chunk",
     ByteChunk = "ByteChunk"
 }
-export interface ConcF extends Conc<any> {
+export interface ConcF extends HKT {
+    type: Conc<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * @tsplus type fncts.Conc
  * @tsplus companion fncts.ConcOps
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
-    [HKT.F]?: ConcF;
-    [HKT.A]?: () => A;
-    [HKT.T]?: Conc<HKT._A<this>>;
-    [HKT.Ix]?: number;
+    readonly _A: () => A;
     readonly _typeId: ConcTypeId;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
@@ -38,6 +40,7 @@ export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatabl
 }
 declare abstract class ConcImplementation<A> implements Iterable<A> {
     readonly _typeId: ConcTypeId;
+    readonly _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     abstract readonly length: number;

package/collection/immutable/Dictionary/definition.d.ts

@@ -1,7 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 interface DictionaryN extends HKT {
-    readonly [HKT.T]: Dictionary<HKT._A<this>>;
+    readonly type: Dictionary<this["A"]>;
 }
 /**
  * @tsplus type fncts.Dictionary

package/collection/immutable/HashMap/api.d.ts

@@ -37,7 +37,7 @@ export declare function makeDefault<K, V>(): HashMap<K, V>;
  * @tsplus fluent fncts.HashMapOps fromFoldable
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F>): <K_, Q, W, X, I, S, R, E>(fka: import("@fncts/typelevel/HKT.js").HKT.Kind<F, K_, Q, W, X, I, S, R, E, readonly [K, A]>) => HashMap<K, A>;
+export declare function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>): <K_, Q, W, X, I, S, R, E>(fka: import("@fncts/typelevel/HKT.js").HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>) => HashMap<K, A>;
 /**
  * Lookup the value for `key` in `map` using custom hash.
  * @tsplus fluent fncts.HashMap getHash
@@ -273,40 +273,40 @@ export declare function foldLeftWithIndex_<K, V, Z>(map: HashMap<K, V>, z: Z, f:
  */
 export declare function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z;
 /**
- * @tsplus fluent fncts.HashMap traverseWithIndex
+ * @tsplus getter fncts.HashMap traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const traverseWithIndex_: P.TraversableWithIndex<HashMapF>["traverseWithIndex"];
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<KF, A>) => <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: unknown, a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<KF, B>>;
 /**
- * @tsplus fluent fncts.HashMap traverse
+ * @tsplus getter fncts.HashMap traverse
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const traverse_: P.Traversable<HashMapF>["traverse"];
+export declare const traverse: P.Traversable<HashMapF>["traverse"];
 /**
  * @tsplus fluent fncts.HashMap unsafeGet
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
 export declare function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined;
 /**
- * @tsplus fluent fncts.HashMap witherWithIndex
+ * @tsplus getter fncts.HashMap witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const witherWithIndex_: P.WitherableWithIndex<HashMapF>["witherWithIndex"];
+export declare const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"];
 /**
- * @tsplus fluent fncts.HashMap wither
+ * @tsplus getter fncts.HashMap wither
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wither_: P.Witherable<HashMapF>["wither"];
+export declare const wither: P.Witherable<HashMapF>["wither"];
 /**
- * @tsplus fluent fncts.HashMap wiltWithIndex
+ * @tsplus getter fncts.HashMap wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wiltWithIndex_: P.WitherableWithIndex<HashMapF>["wiltWithIndex"];
+export declare const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"];
 /**
- * @tsplus fluent fncts.HashMap wilt
+ * @tsplus getter fncts.HashMap wilt
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wilt_: P.Witherable<HashMapF>["wilt"];
+export declare const wilt: P.Witherable<HashMapF>["wilt"];
 /**
  * @tsplus fluent fncts.HashMap unionWith
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"

package/collection/immutable/HashMap/definition.d.ts

@@ -1,10 +1,16 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { HKT } from "@fncts/typelevel/HKT";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Node } from "@fncts/base/collection/immutable/HashMap/internal";
 import type { HashEq } from "@fncts/base/typeclass";
-export interface HashMapF extends HashMap<any, any> {
+export interface HashMapF extends HKT {
+    type: HashMap<this["K"], this["A"]>;
+    variance: {
+        K: "+";
+        A: "+";
+    };
+    index: this["K"];
 }
 /**
  * @tsplus type fncts.HashMap
@@ -16,11 +22,8 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashabl
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly [HKT.F]: HashMapF;
-    readonly [HKT.K]: () => K;
-    readonly [HKT.A]: () => V;
-    readonly [HKT.T]: HashMap<HKT._K<this>, HKT._A<this>>;
-    readonly [HKT.Ix]: K;
+    readonly _K: () => K;
+    readonly _A: () => V;
     constructor(editable: boolean, edit: number, config: HashEq<K>, root: Node<K, V>, size: number);
     [Symbol.iterator](): Iterator<readonly [K, V]>;
     get [Symbol.hash](): number;

package/collection/immutable/ImmutableArray/api.d.ts

@@ -1,13 +1,13 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { These } from "@fncts/base/data/These";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 import { Either } from "@fncts/base/data/Either/definition";
 import { ImmutableNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
-import { HKT } from "@fncts/typelevel/HKT";
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import type { Monoid } from "@fncts/base/typeclass";
 import * as P from "@fncts/base/typeclass";
@@ -45,7 +45,7 @@ export declare function crossWith_<A, B, C>(self: ImmutableArray<A>, fb: Immutab
  * @tsplus fluent fncts.ImmutableArray cross
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<readonly [A, B]>;
+export declare function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<Zipped.Make<A, B>>;
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -505,12 +505,12 @@ export declare function takeLast_<A>(as: ImmutableArray<A>, n: number): Immutabl
 export declare function takeWhile_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
 export declare function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverseWithIndex_: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"];
+export declare const traverseWithIndex_: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
 /**
- * @tsplus fluent fncts.ImmutableArray traverse
+ * @tsplus getter fncts.ImmutableArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare const traverse_: P.Traversable<ImmutableArrayF>["traverse"];
@@ -571,27 +571,25 @@ export declare function unzip<A, B>(self: ImmutableArray<readonly [A, B]>): read
  */
 export declare function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray wilt
+ * @tsplus getter fncts.ImmutableArray wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function wilt_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(self: ImmutableArray<A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>, 
-/** @tsplus auto */
-G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [ImmutableArray<B>, ImmutableArray<B1>]>;
-export declare function wiltWithIndex_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, B1, A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>, 
-/** @tsplus auto */
-G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, readonly [ImmutableArray<B>, ImmutableArray<B1>]>;
+export declare const wiltWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2>(wa: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B_1, B2_1>(f: (k: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/data/Either").Either<B_1, B2_1>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B_1>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2_1>]>;
 /**
- * @tsplus fluent fncts.ImmutableArray wither
+ * @tsplus getter fncts.ImmutableArray wilt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function wither_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(self: ImmutableArray<A>, f: (a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>, 
-/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableArray<B>>;
+export declare const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"];
 /**
- * @tsplus fluent fncts.ImmutableArray witherWithIndex
+ * @tsplus getter fncts.ImmutableArray witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function witherWithIndex_<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(self: ImmutableArray<A>, f: (k: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>, 
-/** @tsplus auto */ G: P.Applicative<G>): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableArray<B>>;
+export declare const witherWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(wa: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (k: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+/**
+ * @tsplus getter fncts.ImmutableArray wither
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare const wither: P.Witherable<ImmutableArrayF>["wither"];
 /**
  * @tsplus fluent fncts.ImmutableArray zip
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"

package/collection/immutable/ImmutableArray/definition.d.ts

@@ -1,9 +1,14 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { HKT } from "@fncts/typelevel/HKT";
 export declare const ImmutableArrayTypeId: unique symbol;
 export declare type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
-export interface ImmutableArrayF extends ImmutableArray<any> {
+export interface ImmutableArrayF extends HKT {
+    type: ImmutableArray<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * @tsplus type fncts.ImmutableArray
@@ -12,10 +17,7 @@ export interface ImmutableArrayF extends ImmutableArray<any> {
 export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
     readonly _array: ReadonlyArray<A>;
     readonly _typeId: ImmutableArrayTypeId;
-    [HKT.F]?: ImmutableArrayF;
-    [HKT.A]?: () => A;
-    [HKT.T]?: ImmutableArray<HKT._A<this>>;
-    [HKT.Ix]?: number;
+    readonly _A: () => A;
     constructor(_array: ReadonlyArray<A>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;