@fncts/base 0.0.12 → 0.0.15

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"
@@ -231,25 +231,25 @@ export declare function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => M
 export declare function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B>;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus fluent fncts.MutableArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): B;
@@ -296,7 +296,7 @@ export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>,
 export declare function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void;
 /**
  * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus fluent fncts.MutableArray get
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A>;
@@ -422,7 +422,7 @@ export declare function partitionMap_<A, B, C>(self: ImmutableArray<A>, f: (a: A
 export declare function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B>;
 /**
  * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus fluent fncts.MutableArray prependAll
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
@@ -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/constructors.d.ts

@@ -1,7 +1,7 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus getter fncts.base.ReadonlyArray asImmutableArray
- * @tsplus getter fncts.base.Array asImmutableArray
+ * @tsplus getter fncts.ReadonlyArray asImmutableArray
+ * @tsplus getter fncts.Array asImmutableArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/constructors"
  */
 export declare function asImmutableArray<A>(self: ReadonlyArray<A>): ImmutableArray<A>;

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,13 +17,14 @@ 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;
     [Symbol.iterator](): IterableIterator<A>;
 }
+/**
+ * @tsplus static fncts.ImmutableArrayOps is
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/definition"
+ */
 export declare function isImmutableArray(u: unknown): u is ImmutableArray<unknown>;

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

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

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

@@ -4,84 +4,84 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Align: P.Align<ImmutableArrayF>;
+export declare const Align: P.Align<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Functor: P.Functor<ImmutableArrayF>;
+export declare const Functor: P.Functor<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF>;
+export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Apply: P.Apply<ImmutableArrayF>;
+export declare const Apply: P.Apply<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Applicative: P.Applicative<ImmutableArrayF>;
+export declare const Applicative: P.Applicative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Alt: P.Alt<ImmutableArrayF>;
+export declare const Alt: P.Alt<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Alternative: P.Alternative<ImmutableArrayF>;
+export declare const Alternative: P.Alternative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Filterable: P.Filterable<ImmutableArrayF>;
+export declare const Filterable: P.Filterable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF>;
+export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Foldable: P.Foldable<ImmutableArrayF>;
+export declare const Foldable: P.Foldable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF>;
+export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FlatMap: P.FlatMap<ImmutableArrayF>;
+export declare const FlatMap: P.FlatMap<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Monad: P.Monad<ImmutableArrayF>;
+export declare const Monad: P.Monad<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Traversable: P.Traversable<ImmutableArrayF>;
+export declare const Traversable: P.Traversable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF>;
+export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Witherable: P.Witherable<ImmutableArrayF>;
+export declare const Witherable: P.Witherable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF>;
+export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;

package/collection/immutable/ImmutableArray.d.ts

@@ -1,6 +1,7 @@
 export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

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

@@ -1,5 +1,6 @@
 import { These } from "@fncts/base/data/These";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import * as P from "@fncts/base/typeclass";
@@ -57,7 +58,7 @@ export declare function crossWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb:
  * @tsplus fluent fncts.ImmutableNonEmptyArray cross
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<readonly [A, B]>;
+export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<Zipped.Make<A, B>>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -163,15 +164,15 @@ export declare function splitAt_<A>(self: ImmutableNonEmptyArray<A>, n: number):
  */
 export declare function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"];
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: ImmutableNonEmptyArray<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, ImmutableNonEmptyArray<B>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
+export declare const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"

package/collection/immutable/ImmutableNonEmptyArray/constructors.d.ts

@@ -6,8 +6,8 @@ export declare function allocWithHead<A>(head: A, length: number): Array<A> & {
     0: A;
 };
 /**
- * @tsplus getter fncts.base.ReadonlyArray unsafeAsNonEmptyArray
- * @tsplus getter fncts.base.Array unsafeAsNonEmptyArray
+ * @tsplus getter fncts.ReadonlyArray unsafeAsNonEmptyArray
+ * @tsplus getter fncts.Array unsafeAsNonEmptyArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
  */
 export declare function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEmptyArray<A>;

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

@@ -1,6 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
+export interface ImmutableNonEmptyArrayF extends HKT {
+    type: ImmutableNonEmptyArray<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
@@ -8,18 +13,17 @@ export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
  */
 export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
     readonly _array: ReadonlyNonEmptyArray<A>;
-    [HKT.F]: ImmutableNonEmptyArrayF;
-    [HKT.T]: ImmutableNonEmptyArray<HKT._A<this>>;
+    readonly _A: () => A;
     constructor(_array: ReadonlyNonEmptyArray<A>);
 }
 /**
- * @tsplus type fncts.base.NonEmptyArray
+ * @tsplus type fncts.NonEmptyArray
  */
 export interface NonEmptyArray<T> extends Array<T> {
     0: T;
 }
 /**
- * @tsplus type fncts.base.ReadonlyNonEmptyArray
+ * @tsplus type fncts.ReadonlyNonEmptyArray
  */
 export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
     readonly 0: T;

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

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

package/collection/immutable/ImmutableNonEmptyArray/instances.d.ts

@@ -4,49 +4,49 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Semialign: P.Semialign<ImmutableNonEmptyArrayF>;
+export declare const Semialign: P.Semialign<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Functor: P.Functor<ImmutableNonEmptyArrayF>;
+export declare const Functor: P.Functor<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF>;
+export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Apply: P.Apply<ImmutableNonEmptyArrayF>;
+export declare const Apply: P.Apply<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Applicative: P.Applicative<ImmutableNonEmptyArrayF>;
+export declare const Applicative: P.Applicative<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Monad: P.Monad<ImmutableNonEmptyArrayF>;
+export declare const Monad: P.Monad<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Foldable: P.Foldable<ImmutableNonEmptyArrayF>;
+export declare const Foldable: P.Foldable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF>;
+export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Traversable: P.Traversable<ImmutableNonEmptyArrayF>;
+export declare const Traversable: P.Traversable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF>;
+export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;

package/collection/immutable/ImmutableNonEmptyArray.d.ts

@@ -1,5 +1,6 @@
 export * from "./ImmutableNonEmptyArray/api.js";
 export * from "./ImmutableNonEmptyArray/constructors.js";
 export * from "./ImmutableNonEmptyArray/definition.js";
+export * from "./ImmutableNonEmptyArray/derivations.js";
 export * from "./ImmutableNonEmptyArray/destructors.js";
 export * from "./ImmutableNonEmptyArray/instances.js";

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

@@ -1,5 +1,5 @@
 /**
- * @tsplus type fncts.base.List.Cons
+ * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
  */
 export declare class Cons<A> implements Iterable<A> {
@@ -10,7 +10,7 @@ export declare class Cons<A> implements Iterable<A> {
     [Symbol.iterator](): Iterator<A>;
 }
 /**
- * @tsplus type fncts.base.List.Nil
+ * @tsplus type fncts.List.Nil
  * @tsplus companion fncts.NilOps
  */
 export declare class Nil<A> implements Iterable<A> {

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

@@ -1,10 +1,14 @@
+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 { Vector } from "@fncts/base/collection/immutable/Vector";
 export declare const RoseTreeTypeId: unique symbol;
 export declare type RoseTreeTypeId = typeof RoseTreeTypeId;
-export interface RoseTreeF extends RoseTree<any> {
+export interface RoseTreeF extends HKT {
+    type: RoseTree<this["A"]>;
+    variance: {
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.RoseTree
@@ -14,9 +18,7 @@ export declare class RoseTree<A> implements Hashable, Equatable {
     readonly value: A;
     readonly forest: Vector<RoseTree<A>>;
     readonly _typeId: RoseTreeTypeId;
-    readonly [HKT.F]: RoseTreeF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: RoseTree<HKT._A<this>>;
+    _A: () => A;
     constructor(value: A, forest: Vector<RoseTree<A>>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

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

@@ -4,7 +4,7 @@ import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
+import type { Eq, Monoid, Ord, Ordering, Traversable } from "@fncts/base/typeclass";
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
  * @complexity O(n)
@@ -541,12 +541,12 @@ export declare function toArray<A>(self: Vector<A>): ReadonlyArray<A>;
  */
 export declare function toList<A>(self: Vector<A>): List<A>;
 /**
- * @tsplus fluent fncts.Vector traverseWithIndex
+ * @tsplus getter fncts.Vector traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"];
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: import("@fncts/base/typeclass").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/Vector/definition").Vector<B>>;
 /**
- * @tsplus fluent fncts.Vector traverse
+ * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare const traverse: Traversable<VectorF>["traverse"];

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

@@ -4,7 +4,12 @@ import { Equatable } from "@fncts/base/typeclass/Equatable";
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
 export declare const VectorTypeId: unique symbol;
 export declare type VectorTypeId = typeof VectorTypeId;
-export interface VectorF extends Vector<any> {
+export interface VectorF extends HKT {
+    type: Vector<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * Represents a Vector of elements.
@@ -25,10 +30,7 @@ export declare class Vector<A> implements Iterable<A> {
     /** @private */
     readonly suffix: A[];
     readonly _typeId: VectorTypeId;
-    readonly [HKT.F]: VectorF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Vector<HKT._A<this>>;
-    readonly [HKT.Ix]: number;
+    readonly _A: () => A;
     constructor(
     /** @private */
     bits: number, 
@@ -45,14 +47,11 @@ export declare class Vector<A> implements Iterable<A> {
     [Symbol.equals](that: unknown): boolean;
 }
 /**
- * @tsplus type fncts.base.MutableVector
+ * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
     readonly _typeId: VectorTypeId;
-    readonly [HKT.F]: VectorF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Vector<HKT._A<this>>;
-    readonly [HKT.Ix]: number;
+    readonly _A: () => A;
     bits: number;
     offset: number;
     length: number;