@fncts/base 0.0.12 → 0.0.15

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/_mjs/util.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=util.mjs.map

package/_mjs/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

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/Array/api.ts

@@ -1,8 +1,8 @@
 import type { Eq } from "@fncts/base/typeclass";
 
 /**
- * @tsplus getter fncts.base.Array elem
- * @tsplus getter fncts.base.ReadonlyArray elem
+ * @tsplus getter fncts.Array elem
+ * @tsplus getter fncts.ReadonlyArray elem
  */
 export function elem<A>(self: ReadonlyArray<A>) {
   return (eq: Eq<A>) =>
@@ -17,32 +17,32 @@ export function elem<A>(self: ReadonlyArray<A>) {
 }
 
 /**
- * @tsplus fluent fncts.base.Array isEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus fluent fncts.Array isEmpty
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
  */
 export function isEmpty<A>(self: ReadonlyArray<A>): boolean {
   return self.length === 0;
 }
 
 /**
- * @tsplus fluent fncts.base.Array isNonEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus fluent fncts.Array isNonEmpty
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
  */
 export function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A> {
   return self.length > 0;
 }
 
 /**
- * @tsplus fluent fncts.base.Array foldLeft
- * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus fluent fncts.Array foldLeft
+ * @tsplus fluent fncts.ReadonlyArray foldLeft
  */
 export function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
 }
 
 /**
- * @tsplus fluent fncts.base.Array foldLeftWithIndex
- * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus fluent fncts.Array foldLeftWithIndex
+ * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
  */
 export function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B {
   let out = b;

package/_src/collection/compat/Array/definition.ts

@@ -1,16 +1,16 @@
 declare global {
   /**
-   * @tsplus type fncts.base.ReadonlyArray
+   * @tsplus type fncts.ReadonlyArray
    */
   export interface ReadonlyArray<T> {}
 
   /**
-   * @tsplus type fncts.base.Array
+   * @tsplus type fncts.Array
    */
   export interface Array<T> {}
 
   /**
-   * @tsplus type fncts.base.ArrayOps
+   * @tsplus type fncts.ArrayOps
    */
   export interface ArrayConstructor {}
 }

package/_src/collection/compat/Array/derivations.ts

@@ -0,0 +1,85 @@
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Check } from "@fncts/typelevel/Check";
+
+import { CompoundError, OptionalIndexError, PrimitiveError } from "@fncts/base/data/DecodeError";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.Array]<_> 10
+ */
+export function deriveGuard<A extends Array<any>>(
+  ...[element]: [A] extends [Array<infer _A>]
+    ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True
+      ? [element: Guard<_A>]
+      : never
+    : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Array.isArray(u)) {
+      return u.every(element.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
+ */
+export const deriveReadonlyArrayGuard: <A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
+      ? [element: Guard<_A>]
+      : never
+    : never
+) => Guard<A> = deriveGuard.unsafeCoerce();
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ */
+export function deriveDecoder<A extends Array<any>>(
+  ...[element]: [A] extends [Array<infer _A>]
+    ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True
+      ? [element: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => {
+    if (Array.isArray(u)) {
+      const errors = Vector.emptyPushable<DecodeError>();
+      let failed   = false;
+      const out    = Array(u.length);
+      for (let i = 0; i < u.length; i++) {
+        const decoded = element.decode(u[i]!);
+        decoded.match2(
+          (err) => {
+            failed = true;
+            errors.push(new OptionalIndexError(i, err));
+          },
+          (warning, value) => {
+            out[i] = value;
+            if (warning.isJust()) {
+              errors.push(warning.value);
+            }
+          },
+        );
+      }
+      if (failed) {
+        return These.left(new CompoundError("Array", errors));
+      }
+      return These.rightOrBoth(errors.length > 0 ? Just(new CompoundError("Array", errors)) : Nothing(), out as A);
+    }
+    return These.left(new PrimitiveError(u, "Array"));
+  }, `Array<${element.label}>`);
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ */
+export function deriveReadonlyArrayDecoder<A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
+      ? [element: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => deriveDecoder(element).decode(u) as These<DecodeError, A>, `ReadonlyArray<${element.label}>`);
+}

package/_src/collection/compat/Array.ts

@@ -1,4 +1,5 @@
 // codegen:start { preset: barrel, include: ./Array/*.ts }
 export * from "./Array/api.js";
 export * from "./Array/definition.js";
+export * from "./Array/derivations.js";
 // codegen:end

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
  */

package/_src/collection/compat.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: type-barrel, include: ./compat/*.ts }
+export type {} from "./compat/Array.js";
+export type {} from "./compat/Record.js";
+// codegen:end

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;
+  declare _A: () => A;
 
   readonly _typeId: ConcTypeId = ConcTypeId;
   abstract readonly length: number;
@@ -40,18 +43,19 @@ export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
   }
 
   [Symbol.equals](that: unknown): boolean {
-    return Conc.isConc(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
+    return Conc.is(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
   }
 }
 
 abstract class ConcImplementation<A> implements Iterable<A> {
   readonly _typeId: ConcTypeId = ConcTypeId;
+  declare _A: () => A;
   get [Symbol.hash](): number {
     return Hashable.iterator(this[Symbol.iterator]());
   }
 
   [Symbol.equals](that: unknown): boolean {
-    return Conc.isConc(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
+    return Conc.is(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
   }
 
   abstract readonly length: number;
@@ -104,8 +108,8 @@ abstract class ConcImplementation<A> implements Iterable<A> {
   }
 
   concat<B>(that: ConcImplementation<B>): ConcImplementation<A | B> {
-    concrete<A>(this);
-    concrete<B>(that);
+    concrete(this);
+    concrete(that);
     if (this._tag === ConcTag.Empty) {
       return that;
     }
@@ -122,7 +126,7 @@ abstract class ConcImplementation<A> implements Iterable<A> {
     }
     const diff = that.depth - this.depth;
     if (Math.abs(diff) <= 1) {
-      return new Concat(this, that);
+      return new Concat<A | B>(this, that);
     } else if (diff < -1) {
       if (this.left.depth >= this.right.depth) {
         const nr = this.right.concat(that);
@@ -161,7 +165,7 @@ abstract class ConcImplementation<A> implements Iterable<A> {
     } else if (n >= this.length) {
       return this;
     } else {
-      concrete<A>(this);
+      concrete(this);
       switch (this._tag) {
         case ConcTag.Empty:
           return _Empty;
@@ -263,9 +267,10 @@ export class Empty<A> extends ConcImplementation<A> {
   }
 }
 
-export const _Empty = new Empty<any>();
+export const _Empty = new Empty<never>();
 
 export class Concat<A> extends ConcImplementation<A> {
+  declare _A: () => A;
   readonly _tag = ConcTag.Concat;
 
   length = this.left.length + this.right.length;
@@ -725,7 +730,7 @@ export function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A> {
 }
 
 /**
- * @tsplus static fncts.ConcOps isConc
+ * @tsplus static fncts.ConcOps is
  */
 export function isConc<A>(u: Iterable<A>): u is Conc<A>;
 export function isConc(u: unknown): u is Conc<unknown>;

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

@@ -0,0 +1,28 @@
+import type { Check } from "@fncts/typelevel/Check";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
+ */
+export function deriveGuard<A extends Conc<any>>(
+  ...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Conc.is(u)) {
+      return u.every(elem.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
+ */
+export function deriveDecoder<A extends Conc<any>>(
+  ...[array, elem]: [A] extends [Conc<infer _A>]
+    ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True
+      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => array.decode(u).map((a) => Conc.from(a) as A), `Conc<${elem.label}>`);
+}

package/_src/collection/immutable/Conc.ts

@@ -2,6 +2,7 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
+export * from "./Conc/derivations.js";
 // codegen:end
 
 // codegen:start { preset: barrel, include: ./Conc/api/*.ts }