@fncts/base 0.0.12 → 0.0.15

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/_src/util.ts

@@ -0,0 +1,8 @@
+// codegen:start { preset: type-barrel, include: ./util/*.ts }
+export type {} from "./util/AnsiFormat.js";
+export type {} from "./util/assert.js";
+export type {} from "./util/pattern.js";
+export type {} from "./util/PCGRandom.js";
+export type {} from "./util/predicates.js";
+export type {} from "./util/rand.js";
+// codegen:end

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

@@ -1,32 +1,32 @@
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 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
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function elem<A>(self: ReadonlyArray<A>): (eq: Eq<A>) => (a: A) => boolean;
 /**
- * @tsplus fluent fncts.base.Array isEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus fluent fncts.Array isEmpty
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
 /**
- * @tsplus fluent fncts.base.Array isNonEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus fluent fncts.Array isNonEmpty
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.base.Array foldLeft
- * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus fluent fncts.Array foldLeft
+ * @tsplus fluent fncts.ReadonlyArray foldLeft
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
- * @tsplus fluent fncts.base.Array foldLeftWithIndex
- * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus fluent fncts.Array foldLeftWithIndex
+ * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;

package/collection/compat/Array/definition.d.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/collection/compat/Array/derivations.d.ts

@@ -0,0 +1,24 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import { These } from "@fncts/base/data/These";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare 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>;
+/**
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare 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>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare 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>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare 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>;

package/collection/compat/Array.d.ts

@@ -1,2 +1,3 @@
 export * from "./Array/api.js";
 export * from "./Array/definition.js";
+export * from "./Array/derivations.js";

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/compat.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./compat/Array.js";
+export type {} from "./compat/Record.js";

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;
+    _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;
+    _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     abstract readonly length: number;
@@ -80,10 +83,11 @@ export declare class Empty<A> extends ConcImplementation<A> {
     arrayIterator(): Iterator<Array<A>>;
     reverseArrayIterator(): Iterator<Array<A>>;
 }
-export declare const _Empty: Empty<any>;
+export declare const _Empty: Empty<never>;
 export declare class Concat<A> extends ConcImplementation<A> {
     readonly left: ConcImplementation<A>;
     readonly right: ConcImplementation<A>;
+    _A: () => A;
     readonly _tag = ConcTag.Concat;
     length: number;
     depth: number;
@@ -104,8 +108,8 @@ declare class AppendN<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.AppendN;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(start: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     append<A1>(a: A1): ConcImplementation<A | A1>;
@@ -120,8 +124,8 @@ declare class PrependN<A> extends ConcImplementation<A> {
     readonly binary: boolean;
     readonly _tag = ConcTag.PrependN;
     length: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(end: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     prepend<A1>(a: A1): ConcImplementation<A | A1>;
@@ -134,8 +138,8 @@ export declare class Singleton<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Singleton;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(value: A);
     get(n: number): A;
@@ -153,8 +157,8 @@ export declare class Slice<A> extends ConcImplementation<A> {
     length: number;
     binary: boolean;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(conc: ConcImplementation<A>, offset: number, l: number);
     get(n: number): A;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
@@ -165,8 +169,8 @@ export declare class Chunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Chunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: ReadonlyArray<A>);
     get(n: number): A;
@@ -181,8 +185,8 @@ export declare class ByteChunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.ByteChunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: Uint8Array);
     get(n: number): A;
@@ -202,7 +206,7 @@ export declare function concrete<A>(_: Conc<A>): asserts _ is Empty<A> | Singlet
  */
 export declare function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A>;
 /**
- * @tsplus static fncts.ConcOps isConc
+ * @tsplus static fncts.ConcOps is
  * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
  */
 export declare function isConc<A>(u: Iterable<A>): u is Conc<A>;

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

@@ -0,0 +1,14 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+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[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare function deriveGuard<A extends Conc<any>>(...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare 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>;

package/collection/immutable/Conc.d.ts

@@ -1,6 +1,7 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
+export * from "./Conc/derivations.js";
 export * from "./Conc/api/empty.js";
 export * from "./Conc/api/makeBy.js";
 export * from "./Conc/api/replicate.js";

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"