@fncts/base 0.0.12 → 0.0.13

package/_mjs/typeclass/Traversable.mjs

@@ -1,33 +1,14 @@
-export const traverse = traverse_1;
 import { identity } from "@fncts/base/data/function";
 export const Traversable = {};
-/**
- * @tsplus fluent fncts.Kind traverse
- */
-
-function traverse_1(ta, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  return F.traverse(ta, f, G);
+export function mkTraverse_() {
+  return i => i();
 }
 /**
- * @tsplus fluent fncts.Kind sequence
+ * @tsplus static fncts.TraversableOps sequence
  */
 
-
-export function sequence(ta,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_1 =
-  /** @tsplus auto */
-  G;
-  const F_1 =
-  /** @tsplus auto */
-  F;
-  return traverse_1(ta, identity, F_1, G_1);
+export function sequence(F) {
+  // @ts-expect-error
+  return ta => G => F.traverse(ta)(G)(identity);
 }
 //# sourceMappingURL=Traversable.mjs.map

package/_mjs/typeclass/Traversable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Traversable.mjs","mappings":"aA2BgBA,QAAQ;AAvBxB,SAASC,QAAT,QAAyB,2BAAzB;AAkBA,OAAO,MAAMC,WAAW,GAAmB,EAApC;AAEP;;;;AAGA,oBAsBEC,EAtBF,EAuBEC,CAvBF;AAwBE;AAAoBC,CAxBtB;AAyBE;AAAoBC,CAzBtB,EAyBuC;EAErC,OAAOD,CAAC,CAACL,QAAF,CAAWG,EAAX,EAAeC,CAAf,EAAkBE,CAAlB,CAAP;AACD;AAED;;;;;AAGA,OAAM,SAAUC,QAAV,CAqBJJ,EArBI;AAsBJ;AAAoBE,CAtBhB;AAuBJ;AAAoBC,CAvBhB,EAuBiC;;EAArC;EAAoBA;;EADpB;EAAoBD;EAGpB,OAAOG,eAAYP,QAAZ,EAAoBQ,GAApB,EAAoBC,GAApB,CAAP;AACD","names":["traverse","identity","Traversable","ta","f","F","G","sequence","traverse_1","F_1","G_1"],"sourceRoot":"","sources":["../../_src/typeclass/Traversable.ts"],"sourcesContent":[null]}
+{"version":3,"file":"Traversable.mjs","mappings":"AAIA,SAASA,QAAT,QAAyB,2BAAzB;AAoBA,OAAO,MAAMC,WAAW,GAAmB,EAApC;AAwBP,OAAM,SAAUC,WAAV,GAAqB;EACzB,OAAQC,CAAD,IAAYA,CAAC,EAApB;AACD;AAED;;;;AAGA,OAAM,SAAUC,QAAV,CACJC,CADI,EACiB;EAUrB;EACA,OAAQC,EAAD,IAASC,CAAD,IAAOF,CAAC,CAACG,QAAF,CAAWF,EAAX,EAAeC,CAAf,EAAkBP,QAAlB,CAAtB;AACD","names":["identity","Traversable","mkTraverse_","i","sequence","F","ta","G","traverse"],"sourceRoot":"","sources":["../../_src/typeclass/Traversable.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/TraversableWithIndex.mjs

@@ -1,9 +1,5 @@
 export const TraversableWithIndex = {};
-export function traverseWithIndex(ta, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  return F.traverseWithIndex(ta, f, G);
+export function mkTraverseWithIndex_() {
+  return i => i();
 }
 //# sourceMappingURL=TraversableWithIndex.mjs.map

package/_mjs/typeclass/TraversableWithIndex.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TraversableWithIndex.mjs","mappings":"AAqBA,OAAO,MAAMA,oBAAoB,GAA4B,EAAtD;AAEP,OAAM,SAAUC,iBAAV,CAsBJC,EAtBI,EAuBJC,CAvBI;AAwBJ;AAAoBC,CAxBhB;AAyBJ;AAAoBC,CAzBhB,EAyBiC;EAErC,OAAOD,CAAC,CAACH,iBAAF,CAAoBC,EAApB,EAAwBC,CAAxB,EAA2BE,CAA3B,CAAP;AACD","names":["TraversableWithIndex","traverseWithIndex","ta","f","F","G"],"sourceRoot":"","sources":["../../_src/typeclass/TraversableWithIndex.ts"],"sourcesContent":[null]}
+{"version":3,"file":"TraversableWithIndex.mjs","mappings":"AA0BA,OAAO,MAAMA,oBAAoB,GAA4B,EAAtD;AA0BP,OAAM,SAAUC,oBAAV,GAA8B;EAClC,OAAQC,CAAD,IAAYA,CAAC,EAApB;AACD","names":["TraversableWithIndex","mkTraverseWithIndex_","i"],"sourceRoot":"","sources":["../../_src/typeclass/TraversableWithIndex.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/Witherable.mjs

@@ -1,47 +1,10 @@
 import * as tsplus_module_1 from "@fncts/base/data/Maybe/constructors";
-import * as tsplus_module_2 from "@fncts/base/typeclass/Functor";
-export const wither = wither_1;
 export const Witherable = {};
 /**
- * @tsplus fluent fncts.Kind wither
+ * @tsplus static fncts.WitherableOps filterA
  */
 
-function wither_1(wa, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_1 =
-  /** @tsplus auto */
-  G;
-  return F.wither(wa, f, G_1);
-}
-
-export function wilt(wa, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_2 =
-  /** @tsplus auto */
-  G;
-  return F.wilt(wa, f, G_2);
-}
-/**
- * @tsplus fluent fncts.Kind filterA
- */
-
-export function filterA(fa, p,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_3 =
-  /** @tsplus auto */
-  G;
-  const F_1 =
-  /** @tsplus auto */
-  F;
-  return wither_1(fa, a => tsplus_module_2.map(p(a), bb => bb ? tsplus_module_1.just(a) : tsplus_module_1.nothing(), G), F_1, G_3);
+export function filterA(F) {
+  return fa => G => p => F.wither(fa)(G)(a => G.map(p(a), bb => bb ? tsplus_module_1.just(a) : tsplus_module_1.nothing()));
 }
 //# sourceMappingURL=Witherable.mjs.map

package/_mjs/typeclass/Witherable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Witherable.mjs","mappings":";;aAyCgBA,MAAM;AALtB,OAAO,MAAMC,UAAU,GAAkB,EAAlC;AAEP;;;;AAGA,kBAsBEC,EAtBF,EAuBEC,CAvBF;AAwBE;AAAoBC,CAxBtB;AAyBE;AAAoBC,CAzBtB,EAyBuC;;EAArC;EAAoBA;EAEpB,OAAOD,CAAC,CAACJ,MAAF,CAASE,EAAT,EAAaC,CAAb,EAAcG,GAAd,CAAP;AACD;;AAED,OAAM,SAAUC,IAAV,CAuBJL,EAvBI,EAwBJC,CAxBI;AAyBJ;AAAoBC,CAzBhB;AA0BJ;AAAoBC,CA1BhB,EA0BiC;;EAArC;EAAoBA;EAapB,OAAOD,CAAC,CAACG,IAAF,CAAOL,EAAP,EAAWC,CAAX,EAAYK,GAAZ,CAAP;AACD;AAED;;;;AAGA,OAAM,SAAUC,OAAV,CAqBJC,EArBI,EAsBJC,CAtBI;AAuBJ;AAAoBP,CAvBhB;AAwBJ;AAAoBC,CAxBhB,EAwBiC;;EAArC;EAAoBA;;EADpB;EAAoBD;EAGpB,OAAOQ,aAAWC,CAAD,IAAOC,qBAAC,CAACD,CAAD,CAAD,EAAUE,EAAD,IAASA,EAAE,GAAGC,qBAAKH,CAAL,CAAH,GAAaG,yBAAjC,EAA6CX,CAA7C,CAAjB,EAAgEY,GAAhE,EAAgEC,GAAhE,CAAP;AACD","names":["wither","Witherable","wa","f","F","G","G_1","wilt","G_2","filterA","fa","p","wither_1","a","tsplus_module_2","bb","tsplus_module_1","F_1","G_3"],"sourceRoot":"","sources":["../../_src/typeclass/Witherable.ts"],"sourcesContent":[null]}
+{"version":3,"file":"Witherable.mjs","mappings":";AAyCA,OAAO,MAAMA,UAAU,GAAkB,EAAlC;AAEP;;;;AAGA,OAAM,SAAUC,OAAV,CACJC,CADI,EACgB;EAQpB,OAAQC,EAAD,IAASC,CAAD,IAAQC,CAAD,IAAOH,CAAC,CAACI,MAAF,CAASH,EAAT,EAAaC,CAAb,EAAiBG,CAAD,IAAOH,CAAC,CAACI,GAAF,CAAMH,CAAC,CAACE,CAAD,CAAP,EAAaE,EAAD,IAASA,EAAE,GAAGC,qBAAKH,CAAL,CAAH,GAAaG,yBAApC,CAAvB,CAA7B;AACD","names":["Witherable","filterA","F","fa","G","p","wither","a","map","bb","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/typeclass/Witherable.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/WitherableWithIndex.mjs

@@ -1,47 +1,12 @@
 import * as tsplus_module_1 from "@fncts/base/data/Maybe/constructors";
-import * as tsplus_module_2 from "@fncts/base/typeclass/Functor";
-export const witherWithIndex = witherWithIndex_1;
 export const WitherableWithIndex = {};
-/**
- * @tsplus fluent fncts.Kind witherWithIndex
- */
-
-function witherWithIndex_1(wa, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_1 =
-  /** @tsplus auto */
-  G;
-  return F.witherWithIndex(wa, f, G_1);
+export function makeWitherWithIndex() {
+  return i => i();
 }
-/**
- * @tsplus fluent fncts.Kind wiltWithIndex
- */
-
-
-export function wiltWithIndex(wa, f,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_2 =
-  /** @tsplus auto */
-  G;
-  return F.wiltWithIndex(wa, f, G_2);
+export function makeWiltWithIndex() {
+  return i => i();
 }
-export function filterWithIndexA(fa, p,
-/** @tsplus auto */
-F,
-/** @tsplus auto */
-G) {
-  const G_3 =
-  /** @tsplus auto */
-  G;
-  const F_1 =
-  /** @tsplus auto */
-  F;
-  return witherWithIndex_1(fa, (i, a) => tsplus_module_2.map(p(i, a), bb => bb ? tsplus_module_1.just(a) : tsplus_module_1.nothing(), G), F_1, G_3);
+export function filterWithIndexA(F) {
+  return fa => G => p => F.witherWithIndex(fa)(G)((i, a) => G.map(p(i, a), bb => bb ? tsplus_module_1.just(a) : tsplus_module_1.nothing()));
 }
 //# sourceMappingURL=WitherableWithIndex.mjs.map

package/_mjs/typeclass/WitherableWithIndex.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"WitherableWithIndex.mjs","mappings":";;aA6CgBA,eAAe;AAL/B,OAAO,MAAMC,mBAAmB,GAA2B,EAApD;AAEP;;;;AAGA,2BAsBEC,EAtBF,EAuBEC,CAvBF;AAwBE;AACAC,CAzBF;AA0BE;AACAC,CA3BF,EA2BmB;;EADjB;EACAA;EAEA,OAAOD,CAAC,CAACJ,eAAF,CAAkBE,EAAlB,EAAsBC,CAAtB,EAAuBG,GAAvB,CAAP;AACD;AAED;;;;;AAGA,OAAM,SAAUC,aAAV,CAuBJL,EAvBI,EAwBJC,CAxBI;AAyBJ;AACAC,CA1BI;AA2BJ;AAAoBC,CA3BhB,EA2BiC;;EAArC;EAAoBA;EAapB,OAAOD,CAAC,CAACG,aAAF,CAAgBL,EAAhB,EAAoBC,CAApB,EAAqBK,GAArB,CAAP;AACD;AAED,OAAM,SAAUC,gBAAV,CAqBJC,EArBI,EAsBJC,CAtBI;AAuBJ;AAAoBP,CAvBhB;AAwBJ;AAAoBC,CAxBhB,EAwBiC;;EAArC;EAAoBA;;EADpB;EAAoBD;EAGpB,OAAOQ,sBAAmB,CAACC,CAAD,EAAIC,CAAJ,KAAUC,qBAAC,CAACF,CAAD,EAAIC,CAAJ,CAAD,EAAaE,EAAD,IAASA,EAAE,GAAGC,qBAAKH,CAAL,CAAH,GAAaG,yBAApC,EAAgDZ,CAAhD,CAA7B,EAA+Ea,GAA/E,EAA+EC,GAA/E,CAAP;AACD","names":["witherWithIndex","WitherableWithIndex","wa","f","F","G","G_1","wiltWithIndex","G_2","filterWithIndexA","fa","p","witherWithIndex_1","i","a","tsplus_module_2","bb","tsplus_module_1","F_1","G_3"],"sourceRoot":"","sources":["../../_src/typeclass/WitherableWithIndex.ts"],"sourcesContent":[null]}
+{"version":3,"file":"WitherableWithIndex.mjs","mappings":";AA6CA,OAAO,MAAMA,mBAAmB,GAA2B,EAApD;AA0BP,OAAM,SAAUC,mBAAV,GAA6B;EACjC,OAAQC,CAAD,IAAYA,CAAC,EAApB;AACD;AA8BD,OAAM,SAAUC,iBAAV,GAA2B;EAC/B,OAAQD,CAAD,IAAYA,CAAC,EAApB;AACD;AAED,OAAM,SAAUE,gBAAV,CACJC,CADI,EACyB;EAQ7B,OAAQC,EAAD,IAASC,CAAD,IAAQC,CAAD,IAAOH,CAAC,CAACI,eAAF,CAAkBH,EAAlB,EAAsBC,CAAtB,EAAyB,CAACL,CAAD,EAAIQ,CAAJ,KAAUH,CAAC,CAACI,GAAF,CAAMH,CAAC,CAACN,CAAD,EAAIQ,CAAJ,CAAP,EAAgBE,EAAD,IAASA,EAAE,GAAGC,qBAAKH,CAAL,CAAH,GAAaG,yBAAvC,CAAnC,CAA7B;AACD","names":["WitherableWithIndex","makeWitherWithIndex","i","makeWiltWithIndex","filterWithIndexA","F","fa","G","p","witherWithIndex","a","map","bb","tsplus_module_1"],"sourceRoot":"","sources":["../../_src/typeclass/WitherableWithIndex.ts"],"sourcesContent":[null]}

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

@@ -1,32 +1,35 @@
 import type * as P from "@fncts/base/typeclass";
 
 /**
- * @tsplus fluent fncts.Iterable traverseToConcWithIndex
+ * @tsplus getter fncts.Iterable traverseToConcWithIndex
  */
-export 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>> {
-  let output     = G.pure<Conc<B>, K, Q, W, X, I, S, R, E>(Conc.empty<B>());
-  const iterator = ta[Symbol.iterator]();
-  let result: IteratorResult<A>;
-  let i          = 0;
-  while (!(result = iterator.next()).done) {
-    output = G.zipWith(output, f(i, result.value), (bs, b) => bs.append(b));
-    i++;
-  }
+export function traverseToConcWithIndex_<A>(ta: Iterable<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E, B>(
+      f: (i: number, 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>> => {
+      let output     = G.pure<Conc<B>, K, Q, W, X, I, S, R, E>(Conc.empty<B>());
+      const iterator = ta[Symbol.iterator]();
+      let result: IteratorResult<A>;
+      let i          = 0;
+      while (!(result = iterator.next()).done) {
+        output = G.zipWith(output, f(i, result.value), (bs, b) => bs.append(b)) as typeof output;
+        i++;
+      }
 
-  return output;
+      return output;
+    };
 }
 
 /**
- * @tsplus fluent fncts.Iterable traverseToConc
+ * @tsplus getter fncts.Iterable traverseToConc
  */
-export function traverseToConc_<G extends HKT, K, Q, W, X, I, S, R, E, A, B>(
+export function traverseToConc_<A>(
   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>> {
-  return ta.traverseToConcWithIndex((_, a) => f(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>> {
+  return (G) => (f) => ta.traverseToConcWithIndex(G)((_, a) => f(a));
 }

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

@@ -2,6 +2,49 @@ import type { Check } from "@fncts/typelevel/Check";
 
 import { CompoundError, MissingKeyError, OptionalKeyError, RequiredKeyError } from "@fncts/base/data/DecodeError";
 
+/**
+ * @tsplus derive fncts.Guard<_> 15
+ */
+export function deriveDictionaryGuard<A extends Record<string, any>>(
+  ...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Guard<A[keyof A]>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (!Derive<Guard<{}>>().is(u)) {
+      return false;
+    }
+    for (const k of Object.keys(u)) {
+      if (!value.is(u[k])) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Guard<_> 15
+ */
+export 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> {
+  const requiredKeysSet = new Set(Object.keys(requiredKeys));
+  return Guard((record): record is A => {
+    const missing = new Set(requiredKeysSet);
+    if (!Derive<Guard<{}>>().is(record)) {
+      return false;
+    }
+    for (const k of Object.keys(record)) {
+      if (requiredKeysSet.has(k) && !value.is(record[k])) {
+        return false;
+      }
+      missing.delete(k);
+    }
+    return missing.size === 0;
+  });
+}
+
 /**
  * @tsplus derive fncts.Decoder<_> 15
  */
@@ -57,3 +100,4 @@ export function deriveDecoder<A extends Record<string, any>>(
     return These.right(res as A);
   }, `Record<string, ${valueDecoder.label}>`);
 }
+

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

@@ -1,6 +1,5 @@
 import type { Concat, ConcF } from "@fncts/base/collection/immutable/Conc/definition";
 import type { Eq } from "@fncts/base/typeclass";
-import type * as P from "@fncts/base/typeclass";
 
 import {
   _Empty,
@@ -14,6 +13,7 @@ import {
 import { EitherTag } from "@fncts/base/data/Either";
 import { identity, tuple } from "@fncts/base/data/function";
 import { Stack } from "@fncts/base/internal/Stack";
+import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus fluent fncts.Conc align
@@ -978,20 +978,18 @@ export function takeWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A> {
 }
 
 /**
- * @tsplus fluent fncts.Conc traverse
+ * @tsplus getter fncts.Conc traverse
  */
-export const traverse: P.Traversable<ConcF>["traverse"] = (self, f, G) => self.traverseWithIndex((_, a) => f(a), G);
+export const traverse: P.Traversable<ConcF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.Conc traverseWithIndex
+ * @tsplus getter fncts.Conc traverseWithIndex
  */
-export 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>> {
-  return self.foldLeftWithIndex(G.pure(Conc.empty()), (i, fbs, a) => fbs.zipWith(f(i, a), (bs, b) => bs.append(b), G));
-}
+export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<ConcF>()(
+  () => (self) => (G) => (f) =>
+    self.foldLeftWithIndex(G.pure(Conc.empty()), (i, fbs, a) => G.zipWith(fbs, f(i, a), (bs, b) => bs.append(b))),
+);
 
 /**
  * @tsplus getter fncts.Conc toBuffer

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

@@ -19,17 +19,20 @@ export const enum ConcTag {
   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 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 = ConcTypeId;
   abstract readonly length: number;
@@ -46,6 +49,7 @@ export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
 
 abstract class ConcImplementation<A> implements Iterable<A> {
   readonly _typeId: ConcTypeId = ConcTypeId;
+  readonly _A!: () => A;
   get [Symbol.hash](): number {
     return Hashable.iterator(this[Symbol.iterator]());
   }

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

@@ -1,5 +1,5 @@
 interface DictionaryN extends HKT {
-  readonly [HKT.T]: Dictionary<HKT._A<this>>;
+  readonly type: Dictionary<this["A"]>;
 }
 
 /**

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

@@ -55,8 +55,8 @@ export function makeDefault<K, V>(): HashMap<K, V> {
  *
  * @tsplus fluent fncts.HashMapOps fromFoldable
  */
-export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F>) {
-  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
+export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>) {
+  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
     return F.foldLeft(fka, makeWith(config), (b, [k, a]) => {
       const oa = b.get(k);
       if (oa.isJust()) {
@@ -529,15 +529,18 @@ export function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) =>
 }
 
 /**
- * @tsplus fluent fncts.HashMap traverseWithIndex
+ * @tsplus getter fncts.HashMap traverseWithIndex
  */
-export const traverseWithIndex_: P.TraversableWithIndex<HashMapF>["traverseWithIndex"] = (ta, f, G) =>
-  ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => b.zipWith(f(k, a), (map, b) => map.set(k, b), G));
+export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<HashMapF>()(
+  () => (ta) => (G) => (f) =>
+    ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => G.zipWith(b, f(k, a), (map, b) => map.set(k, b))),
+);
 
 /**
- * @tsplus fluent fncts.HashMap traverse
+ * @tsplus getter fncts.HashMap traverse
  */
-export const traverse_: P.Traversable<HashMapF>["traverse"] = (ta, f, G) => ta.traverseWithIndex((_, a) => f(a), G);
+export const traverse: P.Traversable<HashMapF>["traverse"] = (ta) => (G) => (f) =>
+  ta.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.HashMap unsafeGet
@@ -547,26 +550,26 @@ export function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined {
 }
 
 /**
- * @tsplus fluent fncts.HashMap witherWithIndex
+ * @tsplus getter fncts.HashMap witherWithIndex
  */
-export const witherWithIndex_: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa, f, G) =>
-  wa.traverseWithIndex(f, G).map(compact, G);
+export const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa) => (G) => (f) =>
+  G.map(wa.traverseWithIndex(G)(f), compact);
 
 /**
- * @tsplus fluent fncts.HashMap wither
+ * @tsplus getter fncts.HashMap wither
  */
-export const wither_: P.Witherable<HashMapF>["wither"] = (wa, f, G) => wa.witherWithIndex((_, a) => f(a), G);
+export const wither: P.Witherable<HashMapF>["wither"] = (wa) => (G) => (f) => wa.witherWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.HashMap wiltWithIndex
+ * @tsplus getter fncts.HashMap wiltWithIndex
  */
-export const wiltWithIndex_: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa, f, G) =>
-  wa.traverseWithIndex(f, G).map(separate, G);
+export const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa) => (G) => (f) =>
+  G.map(wa.traverseWithIndex(G)(f), separate);
 
 /**
- * @tsplus fluent fncts.HashMap wilt
+ * @tsplus getter fncts.HashMap wilt
  */
-export const wilt_: P.Witherable<HashMapF>["wilt"] = (wa, f, G) => wa.wiltWithIndex((_, a) => f(a), G);
+export const wilt: P.Witherable<HashMapF>["wilt"] = (wa) => (G) => (f) => wa.wiltWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.HashMap unionWith

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

@@ -4,18 +4,22 @@ import type { HashEq } from "@fncts/base/typeclass";
 import { isEmptyNode } from "@fncts/base/collection/immutable/HashMap/internal";
 import { identity, tuple } from "@fncts/base/data/function";
 
-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
  * @tsplus companion fncts.HashMapOps
  */
 export class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
-  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(
     public editable: boolean,