@fncts/base 0.0.3 → 0.0.6

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

@@ -81,6 +81,13 @@ export function crossWith_<A, B, C>(
   return self.flatMap((a) => fb.map((b) => f(a, b)));
 }
 
+/**
+ * @tsplus fluent fncts.ImmutableArray cross
+ */
+export function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<readonly [A, B]> {
+  return self.crossWith(fb, tuple);
+}
+
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  */
@@ -90,6 +97,7 @@ export function chainRecDepthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Eithe
 
   while (buffer.length > 0) {
     const e = buffer.shift()!;
+    Either.concrete(e);
     if (e._tag === EitherTag.Left) {
       buffer.unshift(...f(e.left));
     } else {
@@ -109,6 +117,7 @@ export function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Eit
   const out: Array<B>               = [];
 
   function go(e: Either<A, B>): void {
+    Either.concrete(e);
     if (e._tag === "Left") {
       f(e.left).forEach((v) => buffer.push(v));
     } else {
@@ -184,7 +193,7 @@ export function chop_<A, B>(
 ): ImmutableArray<B> {
   const result: Array<B>    = [];
   let cs: ImmutableArray<A> = as;
-  while (isNonEmpty(cs)) {
+  while (cs.isNonEmpty()) {
     const [b, c] = f(cs);
     result.push(b);
     cs = c;
@@ -194,13 +203,6 @@ export function chop_<A, B>(
 
 export const chop = Pipeable(chop_);
 
-/**
- * @tsplus fluent fncts.ImmutableArray chunksOf
- */
-export function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>> {
-  return self.chop((as) => as.splitAt(n));
-}
-
 /**
  * @tsplus fluent fncts.ImmutableArray collectWhile
  */
@@ -226,9 +228,7 @@ function comprehensionLoop<A, R>(
   if (input.length === 0) {
     return g(...scope) ? Eval.now(ImmutableArray(f(...scope))) : Eval.now(ImmutableArray.empty());
   } else {
-    return input[0]!
-      .traverse(Eval.Applicative)((a) => comprehensionLoop(scope.append(a), input.slice(1), f, g))
-      .map((rs) => rs.flatten);
+    return input[0]!.traverse((a) => comprehensionLoop(scope.append(a), input.slice(1), f, g)).map((rs) => rs.flatten);
   }
 }
 
@@ -266,7 +266,6 @@ export function comprehension<A, R>(
 /**
  * @tsplus fluent fncts.ImmutableArray concat
  * @tsplus operator fncts.ImmutableArray +
- * @tsplus operator fncts.base.MutableArray +
  */
 export function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<A | B> {
   const lenx = self._array.length;
@@ -295,20 +294,14 @@ export function deleteAt_<A>(as: ImmutableArray<A>, i: number): Maybe<ImmutableA
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableArray difference
  */
-export function difference_<A>(E: P.Eq<A>) {
-  const elemE_ = elem_(E);
-  return (self: ImmutableArray<A>, ys: ImmutableArray<A>): ImmutableArray<A> => self.filter((a) => !elemE_(ys, a));
-}
-
-/**
- * @tsplus getter fncts.ImmutableArray difference
- */
-export function differenceSelf<A>(self: ImmutableArray<A>) {
-  return (E: P.Eq<A>) =>
-    (that: ImmutableArray<A>): ImmutableArray<A> =>
-      difference_(E)(self, that);
+export function difference_<A>(
+  self: ImmutableArray<A>,
+  ys: ImmutableArray<A>,
+  /** @tsplus auto */ E: P.Eq<A>,
+): ImmutableArray<A> {
+  return self.filter((a) => !ys.elem(a, E));
 }
 
 /**
@@ -344,32 +337,17 @@ export function dropLastWhile_<A>(as: ImmutableArray<A>, p: Predicate<A>): Immut
  * argument which returns the function to use to search for a value of type `A` in
  * an array of type `ImmutableArray<A>`.
  *
- * @constrained
- */
-export function elem_<A>(E: P.Eq<A>) {
-  return (as: ImmutableArray<A>, a: A): boolean => {
-    const predicate = (element: A) => E.equals_(element, a);
-    const len       = as.length;
-    for (let i = 0; i < len; i++) {
-      if (predicate(as._array[i]!)) {
-        return true;
-      }
-    }
-    return false;
-  };
-}
-
-/**
- * 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
  */
-export function elemSelf<A>(self: ImmutableArray<A>) {
-  return (E: P.Eq<A>) =>
-    (a: A): boolean =>
-      elem_(E)(self, a);
+export function elem_<A>(as: ImmutableArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean {
+  const predicate = (element: A) => E.equals(element, a);
+  const len       = as.length;
+  for (let i = 0; i < len; i++) {
+    if (predicate(as._array[i]!)) {
+      return true;
+    }
+  }
+  return false;
 }
 
 /**
@@ -604,59 +582,33 @@ export function foldLeftWithIndexWhile_<A, B>(
   return out;
 }
 
-export function fold<M>(M: Monoid<M>) {
-  return (self: ImmutableArray<M>): M => self.foldLeft(M.nat, M.combine_);
-}
-
 /**
  * @tsplus fluent fncts.ImmutableArray fold
- * @tsplus fluent fncts.base.MutableArray fold
- */
-export function foldSelf<M>(self: ImmutableArray<M>, M: Monoid<M>): M {
-  return self.foldLeft(M.nat, M.combine_);
-}
-
-/**
- * @constrained
- */
-export function foldMapWithIndex_<M>(M: Monoid<M>) {
-  return <A>(self: ImmutableArray<A>, f: (i: number, a: A) => M): M => {
-    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine_(b, f(i, a)));
-  };
-}
-
-/**
- * @tsplus getter fncts.ImmutableArray foldMapWithIndex
- * @tsplus getter fncts.base.MutableArray foldMapWithIndex
  */
-export function foldMapWithIndexSelf<A>(self: ImmutableArray<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      foldMapWithIndex_(M)(self, f);
+export function fold<M>(self: ImmutableArray<M>, /** @tsplus auto */ M: Monoid<M>): M {
+  return self.foldLeft(M.nat, M.combine);
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
  */
-export function foldMap_<M>(M: Monoid<M>) {
-  return <A>(self: ImmutableArray<A>, f: (a: A) => M): M => {
-    return self.foldMapWithIndex(M)((_, a) => f(a));
-  };
+export function foldMapWithIndex_<A, M>(
+  self: ImmutableArray<A>,
+  f: (i: number, a: A) => M,
+  /** @tsplus auto */ M: Monoid<M>,
+): M {
+  return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 
 /**
- * @tsplus getter fncts.ImmutableArray foldMap
- * @tsplus getter fncts.base.MutableArray foldMap
+ * @tsplus fluent fncts.ImmutableArray foldMap
  */
-export function foldMapSelf<A>(self: ImmutableArray<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(self: ImmutableArray<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
+  return self.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
  */
 export function foldRightWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, a: A, b: B) => B): B {
   let r = b;
@@ -668,7 +620,6 @@ export function foldRightWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i:
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldRight
- * @tsplus fluent fncts.base.MutableArray foldRight
  */
 export function foldRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): B {
   return self.foldRightWithIndex(b, (_, a, b) => f(a, b));
@@ -676,7 +627,6 @@ export function foldRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B)
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldRighWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWhile
  */
 export function foldRightWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (a: A, b: B) => B): B {
   return self.foldRightWithIndexWhile(b, p, (_, a, b) => f(a, b));
@@ -684,7 +634,6 @@ export function foldRightWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicat
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
  */
 export function foldRightWithIndexWhile_<A, B>(
   self: ImmutableArray<A>,
@@ -723,7 +672,7 @@ export function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArra
     let i     = 1;
     for (; i < self.length; i++) {
       const a = self._array[i]!;
-      if (E.equals_(a, h)) {
+      if (E.equals(a, h)) {
         out.push(a);
       } else {
         break;
@@ -782,18 +731,15 @@ export function insertAt_<A>(self: ImmutableArray<A>, i: number, a: A): Maybe<Im
   return self.isOutOfBound(i) ? Nothing() : Just(self.unsafeInsertAt(i, a));
 }
 
-export function intersection_<A>(E: P.Eq<A>) {
-  const elemE = elem_(E);
-  return (self: ImmutableArray<A>, that: ImmutableArray<A>): ImmutableArray<A> => self.filter((a) => elemE(that, a));
-}
-
 /**
- * @tsplus getter fncts.ImmutableArray intersection
+ * @tsplus fluent fncts.ImmutableArray intersection
  */
-export function intersectionSelf<A>(self: ImmutableArray<A>) {
-  return (E: P.Eq<A>) =>
-    (that: ImmutableArray<A>): ImmutableArray<A> =>
-      intersection_(E)(self, that);
+export function intersection_<A>(
+  self: ImmutableArray<A>,
+  that: ImmutableArray<A>,
+  /** @tsplus auto */ E: P.Eq<A>,
+): ImmutableArray<A> {
+  return self.filter((a) => that.elem(a, E));
 }
 
 export function intersperse_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A> {
@@ -808,13 +754,6 @@ export function isEmpty<A>(self: ImmutableArray<A>): boolean {
   return self.length === 0;
 }
 
-/**
- * @tsplus fluent fncts.ImmutableArray isNonEmpty
- */
-export function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A> {
-  return self.length > 0;
-}
-
 /**
  * @tsplus fluent fncts.ImmutableArray isOutOfBound
  */
@@ -850,6 +789,7 @@ export function lefts<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<
   const ls: Array<E> = [];
   for (let i = 0; i < self.length; i++) {
     const a = self._array[i]!;
+    Either.concrete(a);
     if (a._tag === EitherTag.Left) {
       ls.push(a.left);
     }
@@ -974,6 +914,7 @@ export function partitionMapWithIndex_<A, B, C>(
   const right = [] as Array<C>;
   for (let i = 0; i < self.length; i++) {
     const ea = f(i, self._array[i]!);
+    Either.concrete(ea);
     switch (ea._tag) {
       case EitherTag.Left:
         left.push(ea.left);
@@ -1045,6 +986,7 @@ export function rights<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray
   const rs: Array<A> = [];
   for (let i = 0; i < self.length; i++) {
     const a = self._array[i]!;
+    Either.concrete(a);
     if (a._tag === EitherTag.Right) {
       rs.push(a.right);
     }
@@ -1095,14 +1037,14 @@ export function scanRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B)
 /**
  * @tsplus fluent fncts.ImmutableArray sort
  */
-export function sort<A extends B, B>(self: ImmutableArray<A>, O: P.Ord<B>): ImmutableArray<A> {
-  return self.isEmpty() || self.length === 1 ? self : self._array.slice().sort(O.compare_).asImmutableArray;
+export function sort<A>(self: ImmutableArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableArray<A> {
+  return self.isEmpty() || self.length === 1 ? self : self._array.slice().sort(O.compare).asImmutableArray;
 }
 
 /**
  * @tsplus fluent fncts.ImmutableArray sortBy
  */
-export function sortBy<A extends B, B>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<B>>): ImmutableArray<A> {
+export function sortBy<A>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<A>>): ImmutableArray<A> {
   return self.sort(Os.fold(P.Ord.getMonoid()));
 }
 
@@ -1186,47 +1128,6 @@ export function spanIndexRight_<A>(as: ImmutableArray<A>, predicate: Predicate<A
   return i;
 }
 
-/**
- * @tsplus fluent fncts.ImmutableArray slice
- */
-export function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A> {
-  return self._array.slice(start, end).asImmutableArray;
-}
-
-/**
- * @tsplus fluent fncts.ImmutableArray splitAt
- */
-export function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  return [as.slice(0, n), as.slice(n)];
-}
-
-/**
- * @tsplus fluent fncts.ImmutableArray splitWhere
- */
-export function splitWhere_<A>(
-  self: ImmutableArray<A>,
-  p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  let cont = true;
-  let i    = 0;
-  while (cont && i < self.length) {
-    if (p(self._array[i]!)) {
-      cont = false;
-    } else {
-      i++;
-    }
-  }
-  return self.splitAt(i);
-}
-
-export const sequence: P.sequence<ImmutableArrayF> = (A) => (self) => self.traverse(A)(identity);
-
-/**
- * @tsplus getter fncts.ImmutableArray sequence
- */
-export const sequenceSelf: P.sequenceSelf<ImmutableArrayF> = (self) => (A) =>
-  unsafeCoerce(self.traverse(A)(unsafeCoerce(identity)));
-
 /**
  * @tsplus getter fncts.ImmutableArray tail
  */
@@ -1262,67 +1163,45 @@ export function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): Immutab
   return init.asImmutableArray;
 }
 
-export const traverseWithIndex_: P.traverseWithIndex_<ImmutableArrayF> = P.mkTraverseWithIndex_<ImmutableArrayF>()(
-  (_) => (A) => (ta, f) =>
-    ta.foldLeftWithIndex(A.pure(ImmutableArray.empty<typeof _.B>()), (i, fbs, a) =>
-      A.zipWith_(fbs, f(i, a), (bs, b) => bs.append(b)),
-    ),
-);
-
 /**
- * @tsplus dataFirst traverseWithIndex_
+ * @tsplus fluent fncts.ImmutableArray traverseWithIndex
  */
-export const traverseWithIndex: P.traverseWithIndex<ImmutableArrayF> = (A) => (f) => (self) =>
-  traverseWithIndex_(A)(self, f);
+export const traverseWithIndex_: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"] = (ta, f, G) =>
+  ta.foldLeftWithIndex(G.pure(ImmutableArray.empty()), (i, fbs, a) => fbs.zipWith(f(i, a), (bs, b) => bs.append(b), G));
 
 /**
- * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ * @tsplus fluent fncts.ImmutableArray traverse
  */
-export const traverseWithIndexSelf: P.traverseWithIndexSelf<ImmutableArrayF> = (self) => (A) => (f) =>
-  traverseWithIndex_(A)(self, f);
-
-export const traverse_: P.traverse_<ImmutableArrayF> = (A) => (self, f) => self.traverseWithIndex(A)((_, a) => f(a));
+export const traverse_: P.Traversable<ImmutableArrayF>["traverse"] = (self, f, G) =>
+  self.traverseWithIndex((_, a) => f(a), G);
 
 /**
- * @tsplus dataFirst traverse_
+ * @tsplus fluent fncts.ImmutableArray union
  */
-export const traverse: P.traverse<ImmutableArrayF> = (A) => (f) => (self) => self.traverseWithIndex(A)((_, a) => f(a));
-
-/**
- * @tsplus getter fncts.ImmutableArray traverse
- */
-export const traverseSelf: P.traverseSelf<ImmutableArrayF> = (self) => (A) => (f) =>
-  self.traverseWithIndex(A)((_, a) => f(a));
-
-export function union_<A>(E: P.Eq<A>) {
-  const elemE = elem_(E);
-  return (self: ImmutableArray<A>, that: ImmutableArray<A>): ImmutableArray<A> =>
-    self.concat(that.filter((a) => !elemE(self, a)));
-}
-
-export function uniq<A>(E: P.Eq<A>) {
-  return (self: ImmutableArray<A>): ImmutableArray<A> => {
-    if (self.length === 1) {
-      return self;
-    }
-    const elemE_ = elem_(E);
-    const out    = [] as Array<A>;
-    const len    = self.length;
-    for (let i = 0; i < len; i++) {
-      const a = self._array[i]!;
-      if (!elemE_(out.asImmutableArray, a)) {
-        out.push(a);
-      }
-    }
-    return out.asImmutableArray;
-  };
+export function union_<A>(
+  self: ImmutableArray<A>,
+  that: ImmutableArray<A>,
+  /** @tsplus auto */ E: P.Eq<A>,
+): ImmutableArray<A> {
+  return self.concat(that.filter((a) => !self.elem(a, E)));
 }
 
 /**
  * @tsplus fluent fncts.ImmutableArray uniq
  */
-export function uniqSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<A> {
-  return uniq(E)(self);
+export function uniq<A>(self: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A> {
+  if (self.length === 1) {
+    return self;
+  }
+  const out = [] as Array<A>;
+  const len = self.length;
+  for (let i = 0; i < len; i++) {
+    const a = self._array[i]!;
+    if (!out.asImmutableArray.elem(a, E)) {
+      out.push(a);
+    }
+  }
+  return out.asImmutableArray;
 }
 
 /**
@@ -1412,88 +1291,123 @@ export function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<Immu
   return as.isOutOfBound(i) ? Nothing() : Just(as.unsafeUpdateAt(i, a));
 }
 
-export const wilt_: P.wilt_<ImmutableArrayF> = (A) => (self, f) => self.wiltWithIndex(A)((_, a) => f(a));
-
-/**
- * @tsplus pipeable fncts.ImmutableArray wilt_
- */
-export const wilt: P.wilt<ImmutableArrayF> = (A) => (f) => (self) => self.wiltWithIndex(A)((_, a) => f(a));
-
 /**
  * @tsplus fluent fncts.ImmutableArray wilt
  */
-export const wiltSelf: P.wiltSelf<ImmutableArrayF> = (self) => (A) => (f) => self.wiltWithIndex(A)((_, a) => f(a));
-
-export const wiltWithIndex_: P.wiltWithIndex_<ImmutableArrayF> = P.mkWiltWithIndex_<ImmutableArrayF>()(
-  (_) => (A) => (self, f) =>
-    A.map_(
-      self.foldLeftWithIndex(A.pure([[] as Array<typeof _.B>, [] as Array<typeof _.B2>] as const), (i, fbs, a) =>
-        A.zipWith_(f(i, a), fbs, (eb, r) =>
-          eb.match(
-            (b1) => {
-              r[0].push(b1);
-              return r;
-            },
-            (b2) => {
-              r[1].push(b2);
-              return r;
-            },
-          ),
+export 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>]> {
+  return self
+    .foldLeft(
+      G.pure([[] as Array<B>, [] as Array<B1>] as const) as HKT.Kind<
+        G,
+        KG,
+        QG,
+        WG,
+        XG,
+        IG,
+        SG,
+        RG,
+        EG,
+        readonly [B[], B1[]]
+      >,
+      (fbs, a) =>
+        f(a).zipWith(
+          fbs,
+          (eb, r) =>
+            eb.match(
+              (b1) => {
+                r[0].push(b1);
+                return r;
+              },
+              (b2) => {
+                r[1].push(b2);
+                return r;
+              },
+            ),
+          G,
         ),
-      ),
-      ([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray],
-    ),
-);
-
-/**
- * @tsplus dataFirst wiltWithIndex_
- */
-export const wiltWithIndex: P.wiltWithIndex<ImmutableArrayF> = (A) => (f) => (self) => wiltWithIndex_(A)(self, f);
-
-/**
- * @tsplus getter fncts.ImmutableArray wiltWithIndex
- */
-export const wiltWithIndexSelf: P.wiltWithIndexSelf<ImmutableArrayF> = (self) => (A) => (f) =>
-  wiltWithIndex_(A)(self, f);
+    )
+    .map(([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray], G);
+}
 
-export const wither_: P.wither_<ImmutableArrayF> = (A) => (self, f) => witherWithIndex_(A)(self, (_, a) => f(a));
+export 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>]> {
+  return self
+    .foldLeftWithIndex(
+      G.pure([[] as Array<B>, [] as Array<B1>] as const) as HKT.Kind<
+        G,
+        KG,
+        QG,
+        WG,
+        XG,
+        IG,
+        SG,
+        RG,
+        EG,
+        readonly [B[], B1[]]
+      >,
+      (i, fbs, a) =>
+        f(i, a).zipWith(
+          fbs,
+          (eb, r) =>
+            eb.match(
+              (b1) => {
+                r[0].push(b1);
+                return r;
+              },
+              (b2) => {
+                r[1].push(b2);
+                return r;
+              },
+            ),
+          G,
+        ),
+    )
+    .map(([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray], G);
+}
 
 /**
- * @tsplus dataFirst wither_
+ * @tsplus fluent fncts.ImmutableArray wither
  */
-export const wither: P.wither<ImmutableArrayF> = (A) => (f) => (self) => wither_(A)(self, f);
+export 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>> {
+  return self.witherWithIndex((_, a) => f(a));
+}
 
 /**
- * @tsplus fluent fncts.ImmutableArray wither
+ * @tsplus fluent fncts.ImmutableArray witherWithIndex
  */
-export const witherSelf: P.witherSelf<ImmutableArrayF> = (self) => (A) => (f) =>
-  witherWithIndex_(A)(self, (_, a) => f(a));
-
-export const witherWithIndex_: P.witherWithIndex_<ImmutableArrayF> = P.mkWitherWithIndex_<ImmutableArrayF>()(
-  (_) => (A) => (self, f) =>
-    A.map_(
-      self.foldLeftWithIndex(A.pure([] as Array<typeof _.B>), (i, b, a) =>
-        A.zipWith_(f(i, a), b, (maybeB, bs) => {
+export 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>> {
+  return self
+    .foldLeftWithIndex(G.pure([] as Array<B>) as HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B[]>, (i, b, a) =>
+      f(i, a).zipWith(
+        b,
+        (maybeB, bs) => {
           if (maybeB.isJust()) {
             bs.push(maybeB.value);
           }
           return bs;
-        }),
+        },
+        G,
       ),
-      (bs) => bs.asImmutableArray,
-    ),
-);
-
-/**
- * @tsplus dataFirst witherWithIndex_
- */
-export const witherWithIndex: P.witherWithIndex<ImmutableArrayF> = (A) => (f) => (self) => witherWithIndex_(A)(self, f);
-
-/**
- * @tsplus fluent fncts.ImmutableArray witherWithIndex
- */
-export const witherWithIndexSelf: P.witherWithIndexSelf<ImmutableArrayF> = (self) => (A) => (f) =>
-  witherWithIndex_(A)(self, f);
+    )
+    .map((bs) => bs.asImmutableArray, G);
+}
 
 /**
  * @tsplus fluent fncts.ImmutableArray zip

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

@@ -1,12 +1,18 @@
 export const ImmutableArrayTypeId = Symbol.for("fncts.ImmutableArray");
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 
+export interface ImmutableArrayF extends ImmutableArray<any> {}
+
 /**
  * @tsplus type fncts.ImmutableArray
  * @tsplus companion fncts.ImmutableArrayOps
  */
 export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
   readonly _typeId: ImmutableArrayTypeId = ImmutableArrayTypeId;
+  [HKT.F]?: ImmutableArrayF;
+  [HKT.A]?: () => A;
+  [HKT.T]?: ImmutableArray<HKT._A<this>>;
+  [HKT.Ix]?: number;
   constructor(readonly _array: ReadonlyArray<A>) {}
 
   [Symbol.equals](that: unknown): boolean {
@@ -29,11 +35,3 @@ export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
 export function isImmutableArray(u: unknown): u is ImmutableArray<unknown> {
   return hasTypeId(u, ImmutableArrayTypeId);
 }
-
-export interface ImmutableArrayF extends HKT {
-  readonly type: ImmutableArray<this["A"]>;
-  readonly variance: {
-    readonly A: "+";
-  };
-  readonly index: number;
-}