@fncts/base 0.0.3 → 0.0.6

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

@@ -1,10 +1,9 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
-export interface ConcF extends HKT {
-    readonly type: Conc<this["A"]>;
-    readonly index: number;
-}
+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";
 export declare const BUFFER_SIZE = 64;
 export declare const UPDATE_BUFFER_SIZE = 256;
 export declare const ConcTypeId: unique symbol;
@@ -20,19 +19,27 @@ export declare const enum ConcTag {
     Chunk = "Chunk",
     ByteChunk = "ByteChunk"
 }
+export interface ConcF extends Conc<any> {
+}
 /**
  * @tsplus type fncts.Conc
  * @tsplus companion fncts.ConcOps
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
+    [HKT.F]?: ConcF;
+    [HKT.A]?: () => A;
+    [HKT.T]?: Conc<HKT._A<this>>;
+    [HKT.Ix]?: number;
     readonly _typeId: ConcTypeId;
-    readonly _A: () => A;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
-declare abstract class ConcImplementation<A> extends Conc<A> {
+declare abstract class ConcImplementation<A> implements Iterable<A> {
+    readonly _typeId: ConcTypeId;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
     abstract readonly length: number;
     abstract readonly binary: boolean;
     abstract get(n: number): A;

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 type: Dictionary<this["A"]>;
+    readonly [HKT.T]: Dictionary<HKT._A<this>>;
 }
 /**
  * @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, 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>;
+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>;
 /**
  * Lookup the value for `key` in `map` using custom hash.
  * @tsplus fluent fncts.HashMap getHash
@@ -272,53 +272,41 @@ export declare function foldLeftWithIndex_<K, V, Z>(map: HashMap<K, V>, z: Z, f:
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
 export declare function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z;
-export declare const traverseWithIndex_: P.traverseWithIndex_<HashMapF>;
-export declare const traverseWithIndex: P.traverseWithIndex<HashMapF>;
 /**
- * @tsplus getter fncts.HashMap traverseWithIndex
+ * @tsplus fluent fncts.HashMap traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const traverseWithIndexSelf: P.traverseWithIndexSelf<HashMapF>;
-export declare const traverse_: P.traverse_<HashMapF>;
-export declare const traverse: P.traverse<HashMapF>;
+export declare const traverseWithIndex_: P.TraversableWithIndex<HashMapF>["traverseWithIndex"];
 /**
- * @tsplus fluent fncts.HashMap unsafeGet
+ * @tsplus fluent fncts.HashMap traverse
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined;
+export declare const traverse_: P.Traversable<HashMapF>["traverse"];
 /**
- * @tsplus getter fncts.HashMap traverse
+ * @tsplus fluent fncts.HashMap unsafeGet
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const traverseSelf: P.traverseSelf<HashMapF>;
-export declare const witherWithIndex_: P.witherWithIndex_<HashMapF>;
-export declare const witherWithIndex: P.witherWithIndex<HashMapF>;
+export declare function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined;
 /**
- * @tsplus getter fncts.HashMap witherWithIndex
+ * @tsplus fluent fncts.HashMap witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const witherWithIndexSelf: P.witherWithIndexSelf<HashMapF>;
-export declare const wither_: P.wither_<HashMapF>;
-export declare const wither: P.wither<HashMapF>;
+export declare const witherWithIndex_: P.WitherableWithIndex<HashMapF>["witherWithIndex"];
 /**
- * @tsplus getter fncts.HashMap wither
+ * @tsplus fluent fncts.HashMap wither
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const witherSelf: P.witherSelf<HashMapF>;
-export declare const wiltWithIndex_: P.wiltWithIndex_<HashMapF>;
-export declare const wiltWithIndex: P.wiltWithIndex<HashMapF>;
+export declare const wither_: P.Witherable<HashMapF>["wither"];
 /**
- * @tsplus getter fncts.HashMap wiltWithIndex
+ * @tsplus fluent fncts.HashMap wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wiltWithIndexSelf: P.wiltWithIndexSelf<HashMapF>;
-export declare const wilt_: P.wilt_<HashMapF>;
-export declare const wilt: P.wilt<HashMapF>;
+export declare const wiltWithIndex_: P.WitherableWithIndex<HashMapF>["wiltWithIndex"];
 /**
- * @tsplus getter fncts.HashMap wilt
+ * @tsplus fluent fncts.HashMap wilt
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wiltSelf: P.wiltSelf<HashMapF>;
+export declare const wilt_: P.Witherable<HashMapF>["wilt"];
 /**
  * @tsplus fluent fncts.HashMap unionWith
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"

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

@@ -1,15 +1,10 @@
-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 HKT {
-    readonly type: HashMap<this["K"], this["A"]>;
-    readonly variance: {
-        K: "_";
-        A: "+";
-    };
+export interface HashMapF extends HashMap<any, any> {
 }
 /**
  * @tsplus type fncts.HashMap
@@ -21,8 +16,11 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashabl
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly _K: () => K;
-    readonly _V: () => V;
+    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;
     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/HashMap/internal.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Nothing, Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Eq } from "@fncts/base/typeclass";
 export declare const SIZE = 5;
 export declare const BUCKET_SIZE: number;
@@ -29,7 +29,7 @@ export declare const _EmptyNode: EmptyNode<never, never>;
 export declare function isEmptyNode(a: unknown): a is EmptyNode<unknown, unknown>;
 export declare function isLeaf<K, V>(node: Node<K, V>): node is EmptyNode<K, V> | LeafNode<K, V> | CollisionNode<K, V>;
 export declare function canEditNode<K, V>(edit: number, node: Node<K, V>): boolean;
-export declare type KeyEq<K> = Eq<K>["equals_"];
+export declare type KeyEq<K> = Eq<K>["equals"];
 export declare type UpdateFn<V> = (v: Maybe<V>) => Maybe<V>;
 export declare class LeafNode<K, V> {
     readonly edit: number;

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

@@ -1,3 +1,4 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
 import * as P from "@fncts/base/typeclass";
 /**
  * @tsplus type fncts.HashSet

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

@@ -0,0 +1,6 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus fluent fncts.ImmutableArray chunksOf
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/chunksOf"
+ */
+export declare function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>>;

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

@@ -0,0 +1,6 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus fluent fncts.ImmutableArray slice
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/slice"
+ */
+export declare function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A>;

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

@@ -0,0 +1,6 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+/**
+ * @tsplus fluent fncts.ImmutableArray splitAt
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitAt"
+ */
+export declare function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>];

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

@@ -0,0 +1,7 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus fluent fncts.ImmutableArray splitWhere
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitWhere"
+ */
+export declare function splitWhere_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];

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

@@ -1,5 +1,5 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { ImmutableNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
@@ -7,6 +7,7 @@ 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";
@@ -40,6 +41,11 @@ export declare function append_<A, B>(self: ImmutableArray<A>, last: B): Immutab
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function crossWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (a: A, b: B) => C): ImmutableArray<C>;
+/**
+ * @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]>;
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -78,11 +84,6 @@ export declare function chop_<A, B>(as: ImmutableArray<A>, f: (as: ImmutableNonE
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare const chop: <A, B>(f: (as: import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>) => readonly [B, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>]) => (as: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>;
-/**
- * @tsplus fluent fncts.ImmutableArray chunksOf
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>>;
 /**
  * @tsplus fluent fncts.ImmutableArray collectWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -99,7 +100,6 @@ export declare function comprehension<A, R>(input: [ImmutableArray<A>], f: (a: A
 /**
  * @tsplus fluent fncts.ImmutableArray concat
  * @tsplus operator fncts.ImmutableArray +
- * @tsplus operator fncts.base.MutableArray +
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<A | B>;
@@ -109,14 +109,11 @@ export declare function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableAr
  */
 export declare function deleteAt_<A>(as: ImmutableArray<A>, i: number): Maybe<ImmutableArray<A>>;
 /**
- * @constrained
- */
-export declare function difference_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, ys: ImmutableArray<A>) => ImmutableArray<A>;
-/**
- * @tsplus getter fncts.ImmutableArray difference
+ * @tsplus fluent fncts.ImmutableArray difference
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function differenceSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (that: ImmutableArray<A>) => ImmutableArray<A>;
+export declare function difference_<A>(self: ImmutableArray<A>, ys: ImmutableArray<A>, 
+/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray drop
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -141,18 +138,10 @@ export declare function dropLastWhile_<A>(as: ImmutableArray<A>, p: Predicate<A>
  * Test if a value is a member of an array. Takes an `Eq<A>` as a single
  * argument which returns the function to use to search for a value of type `A` in
  * an array of type `ImmutableArray<A>`.
- *
- * @constrained
- */
-export declare function elem_<A>(E: P.Eq<A>): (as: ImmutableArray<A>, a: A) => boolean;
-/**
- * Test if a value is a member of an array. Takes an `Eq<A>` as a single
- * argument which returns the function to use to search for a value of type `A` in
- * an array of type `ImmutableArray<A>`.
- * @tsplus getter fncts.ImmutableArray elem
+ * @tsplus fluent fncts.ImmutableArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function elemSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (a: A) => boolean;
+export declare function elem_<A>(as: ImmutableArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean;
 /**
  * @tsplus fluent fncts.ImmutableArray every
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -264,54 +253,39 @@ export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: P
  * @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;
-export declare function fold<M>(M: Monoid<M>): (self: ImmutableArray<M>) => M;
 /**
  * @tsplus fluent fncts.ImmutableArray fold
- * @tsplus fluent fncts.base.MutableArray fold
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldSelf<M>(self: ImmutableArray<M>, M: Monoid<M>): M;
-/**
- * @constrained
- */
-export declare function foldMapWithIndex_<M>(M: Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>, f: (i: number, a: A) => M) => M;
+export declare function fold<M>(self: ImmutableArray<M>, /** @tsplus auto */ M: Monoid<M>): M;
 /**
- * @tsplus getter fncts.ImmutableArray foldMapWithIndex
- * @tsplus getter fncts.base.MutableArray foldMapWithIndex
+ * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldMapWithIndexSelf<A>(self: ImmutableArray<A>): <M>(M: Monoid<M>) => (f: (i: number, a: A) => M) => M;
+export declare function foldMapWithIndex_<A, M>(self: ImmutableArray<A>, f: (i: number, a: A) => M, 
+/** @tsplus auto */ M: Monoid<M>): M;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.ImmutableArray foldMap
- * @tsplus getter fncts.base.MutableArray foldMap
+ * @tsplus fluent fncts.ImmutableArray foldMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldMapSelf<A>(self: ImmutableArray<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<A, M>(self: ImmutableArray<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldRightWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, a: A, b: B) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldRight
- * @tsplus fluent fncts.base.MutableArray foldRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldRighWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldRightWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (a: A, b: B) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B): B;
@@ -352,23 +326,18 @@ export declare function init<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function insertAt_<A>(self: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableNonEmptyArray<A>>;
-export declare function intersection_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, that: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus getter fncts.ImmutableArray intersection
+ * @tsplus fluent fncts.ImmutableArray intersection
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function intersectionSelf<A>(self: ImmutableArray<A>): (E: P.Eq<A>) => (that: ImmutableArray<A>) => ImmutableArray<A>;
+export declare function intersection_<A>(self: ImmutableArray<A>, that: ImmutableArray<A>, 
+/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
 export declare function intersperse_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray isEmpty
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function isEmpty<A>(self: ImmutableArray<A>): boolean;
-/**
- * @tsplus fluent fncts.ImmutableArray isNonEmpty
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray isOutOfBound
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -486,12 +455,12 @@ export declare function scanRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A
  * @tsplus fluent fncts.ImmutableArray sort
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function sort<A extends B, B>(self: ImmutableArray<A>, O: P.Ord<B>): ImmutableArray<A>;
+export declare function sort<A>(self: ImmutableArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray sortBy
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function sortBy<A extends B, B>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<B>>): ImmutableArray<A>;
+export declare function sortBy<A>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<A>>): ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray spanLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -514,27 +483,6 @@ export declare function spanIndexLeft_<A>(self: ImmutableArray<A>, p: Predicate<
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function spanIndexRight_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): number;
-/**
- * @tsplus fluent fncts.ImmutableArray slice
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A>;
-/**
- * @tsplus fluent fncts.ImmutableArray splitAt
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>];
-/**
- * @tsplus fluent fncts.ImmutableArray splitWhere
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function splitWhere_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
-export declare const sequence: P.sequence<ImmutableArrayF>;
-/**
- * @tsplus getter fncts.ImmutableArray sequence
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare const sequenceSelf: P.sequenceSelf<ImmutableArrayF>;
 /**
  * @tsplus getter fncts.ImmutableArray tail
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -556,33 +504,27 @@ 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>;
-export declare const traverseWithIndex_: P.traverseWithIndex_<ImmutableArrayF>;
-/**
- * @tsplus dataFirst traverseWithIndex_
- */
-export declare const traverseWithIndex: P.traverseWithIndex<ImmutableArrayF>;
 /**
- * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ * @tsplus fluent fncts.ImmutableArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverseWithIndexSelf: P.traverseWithIndexSelf<ImmutableArrayF>;
-export declare const traverse_: P.traverse_<ImmutableArrayF>;
+export declare const traverseWithIndex_: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"];
 /**
- * @tsplus dataFirst traverse_
+ * @tsplus fluent fncts.ImmutableArray traverse
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverse: P.traverse<ImmutableArrayF>;
+export declare const traverse_: P.Traversable<ImmutableArrayF>["traverse"];
 /**
- * @tsplus getter fncts.ImmutableArray traverse
+ * @tsplus fluent fncts.ImmutableArray union
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverseSelf: P.traverseSelf<ImmutableArrayF>;
-export declare function union_<A>(E: P.Eq<A>): (self: ImmutableArray<A>, that: ImmutableArray<A>) => ImmutableArray<A>;
-export declare function uniq<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+export declare function union_<A>(self: ImmutableArray<A>, that: ImmutableArray<A>, 
+/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function uniqSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<A>;
+export declare function uniq<A>(self: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray unprepend
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -627,47 +569,28 @@ export declare function unzip<A, B>(self: ImmutableArray<readonly [A, B]>): read
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableArray<A>>;
-export declare const wilt_: P.wilt_<ImmutableArrayF>;
-/**
- * @tsplus pipeable fncts.ImmutableArray wilt_
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare const wilt: P.wilt<ImmutableArrayF>;
 /**
  * @tsplus fluent fncts.ImmutableArray wilt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const wiltSelf: P.wiltSelf<ImmutableArrayF>;
-export declare const wiltWithIndex_: P.wiltWithIndex_<ImmutableArrayF>;
-/**
- * @tsplus dataFirst wiltWithIndex_
- */
-export declare const wiltWithIndex: P.wiltWithIndex<ImmutableArrayF>;
-/**
- * @tsplus getter fncts.ImmutableArray wiltWithIndex
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare const wiltWithIndexSelf: P.wiltWithIndexSelf<ImmutableArrayF>;
-export declare const wither_: P.wither_<ImmutableArrayF>;
-/**
- * @tsplus dataFirst wither_
- */
-export declare const wither: P.wither<ImmutableArrayF>;
+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>]>;
 /**
  * @tsplus fluent fncts.ImmutableArray wither
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const witherSelf: P.witherSelf<ImmutableArrayF>;
-export declare const witherWithIndex_: P.witherWithIndex_<ImmutableArrayF>;
-/**
- * @tsplus dataFirst witherWithIndex_
- */
-export declare const witherWithIndex: P.witherWithIndex<ImmutableArrayF>;
+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>>;
 /**
  * @tsplus fluent fncts.ImmutableArray witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const witherWithIndexSelf: P.witherWithIndexSelf<ImmutableArrayF>;
+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>>;
 /**
  * @tsplus fluent fncts.ImmutableArray zip
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"

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

@@ -3,6 +3,8 @@ 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> {
+}
 /**
  * @tsplus type fncts.ImmutableArray
  * @tsplus companion fncts.ImmutableArrayOps
@@ -10,16 +12,13 @@ export declare type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 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;
     constructor(_array: ReadonlyArray<A>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
     [Symbol.iterator](): IterableIterator<A>;
 }
 export declare function isImmutableArray(u: unknown): u is ImmutableArray<unknown>;
-export interface ImmutableArrayF extends HKT {
-    readonly type: ImmutableArray<this["A"]>;
-    readonly variance: {
-        readonly A: "+";
-    };
-    readonly index: number;
-}