@fncts/base 0.0.20 → 0.0.22

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

@@ -2,90 +2,96 @@ import type { ImmutableArrayF } from "@fncts/base/collection/immutable/Immutable
 import type { Monoid } from "@fncts/base/typeclass";
 
 import { EitherTag } from "@fncts/base/data/Either";
-import { identity, tuple } from "@fncts/base/data/function";
+import { identity, pipe, tuple } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
 
 /**
- * @tsplus fluent fncts.ImmutableArray alignWith
+ * @tsplus pipeable fncts.ImmutableArray alignWith
  */
-export function alignWith_<A, B, C>(
-  self: ImmutableArray<A>,
-  fb: ImmutableArray<B>,
-  f: (_: These<A, B>) => C,
-): ImmutableArray<C> {
-  const selfArray = self._array;
-  const thatArray = fb._array;
-  const minlen    = Math.min(selfArray.length, thatArray.length);
-  const maxlen    = Math.max(selfArray.length, thatArray.length);
-  const ret       = Array<C>(maxlen);
-  for (let i = 0; i < minlen; i++) {
-    ret[i] = f(These.both(selfArray[i]!, thatArray[i]!));
-  }
-  if (minlen === maxlen) {
-    return ret.asImmutableArray;
-  } else if (selfArray.length > thatArray.length) {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(These.left(selfArray[i]!));
+export function alignWith<A, B, C>(fb: ImmutableArray<B>, f: (_: These<A, B>) => C) {
+  return (self: ImmutableArray<A>): ImmutableArray<C> => {
+    const selfArray = self._array;
+    const thatArray = fb._array;
+    const minlen    = Math.min(selfArray.length, thatArray.length);
+    const maxlen    = Math.max(selfArray.length, thatArray.length);
+    const ret       = Array<C>(maxlen);
+    for (let i = 0; i < minlen; i++) {
+      ret[i] = f(These.both(selfArray[i]!, thatArray[i]!));
     }
-  } else {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(These.right(thatArray[i]!));
+    if (minlen === maxlen) {
+      return ret.asImmutableArray;
+    } else if (selfArray.length > thatArray.length) {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(These.left(selfArray[i]!));
+      }
+    } else {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(These.right(thatArray[i]!));
+      }
     }
-  }
-  return ret.asImmutableArray;
+    return ret.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray align
+ * @tsplus pipeable fncts.ImmutableArray align
  */
-export function align_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<These<A, B>> {
-  return self.alignWith(fb, identity);
+export function align<B>(fb: ImmutableArray<B>) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<These<A, B>> => {
+    return self.alignWith(fb, identity);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray alt
+ * @tsplus pipeable fncts.ImmutableArray alt
  */
-export function alt_<A, B>(self: ImmutableArray<A>, that: Lazy<ImmutableArray<B>>): ImmutableArray<A | B> {
-  return self.concat(that());
+export function alt<B>(that: Lazy<ImmutableArray<B>>) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A | B> => {
+    return self.concat(that());
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray ap
+ * @tsplus pipeable fncts.ImmutableArray ap
  */
-export function ap_<A, B>(self: ImmutableArray<(a: A) => B>, fa: ImmutableArray<A>): ImmutableArray<B> {
-  return self.flatMap((f) => fa.map(f));
+export function ap<A>(fa: ImmutableArray<A>) {
+  return <B>(self: ImmutableArray<(a: A) => B>): ImmutableArray<B> => {
+    return self.flatMap((f) => fa.map(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray append
+ * @tsplus pipeable fncts.ImmutableArray append
  */
-export function append_<A, B>(self: ImmutableArray<A>, last: B): ImmutableArray<A | B> {
-  const selfArray = self._array;
-  const len       = selfArray.length;
-  const r         = Array<A | B>(len + 1);
-  r[len]          = last;
-  for (let i = 0; i < len; i++) {
-    r[i] = selfArray[i]!;
-  }
-  return r.asImmutableArray;
+export function append<B>(last: B) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A | B> => {
+    const selfArray = self._array;
+    const len       = selfArray.length;
+    const r         = Array<A | B>(len + 1);
+    r[len]          = last;
+    for (let i = 0; i < len; i++) {
+      r[i] = selfArray[i]!;
+    }
+    return r.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray crossWith
+ * @tsplus pipeable fncts.ImmutableArray crossWith
  */
-export function crossWith_<A, B, C>(
-  self: ImmutableArray<A>,
-  fb: ImmutableArray<B>,
-  f: (a: A, b: B) => C,
-): ImmutableArray<C> {
-  return self.flatMap((a) => fb.map((b) => f(a, b)));
+export function crossWith<A, B, C>(fb: ImmutableArray<B>, f: (a: A, b: B) => C) {
+  return (self: ImmutableArray<A>): ImmutableArray<C> => {
+    return self.flatMap((a) => fb.map((b) => f(a, b)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray cross
+ * @tsplus pipeable fncts.ImmutableArray cross
  */
-export function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<Zipped.Make<A, B>> {
-  return self.crossWith(fb, (a, b) => Zipped(a, b));
+export function cross<B>(fb: ImmutableArray<B>) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<Zipped.Make<A, B>> => {
+    return self.crossWith(fb, (a, b) => Zipped(a, b));
+  };
 }
 
 /**
@@ -137,40 +143,41 @@ export function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Eit
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray flatMapWithIndex
  */
-export function flatMapWithIndex_<A, B>(
-  self: ImmutableArray<A>,
-  f: (i: number, a: A) => ImmutableArray<B>,
-): ImmutableArray<B> {
-  let outLen      = 0;
-  const selfArray = self._array;
-  const len       = selfArray.length;
-  const temp      = Array<Array<B>>(len);
-  for (let i = 0; i < len; i++) {
-    const e   = selfArray[i]!;
-    const arr = f(i, e)._array;
-    outLen   += arr.length;
-    temp[i]   = arr! as Array<B>;
-  }
-  const out = Array<B>(outLen);
-  let start = 0;
-  for (let i = 0; i < len; i++) {
-    const arr = temp[i]!;
-    const l   = arr.length;
-    for (let j = 0; j < l; j++) {
-      out[j + start] = arr[j]!;
+export function flatMapWithIndex<A, B>(f: (i: number, a: A) => ImmutableArray<B>) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    let outLen      = 0;
+    const selfArray = self._array;
+    const len       = selfArray.length;
+    const temp      = Array<Array<B>>(len);
+    for (let i = 0; i < len; i++) {
+      const e   = selfArray[i]!;
+      const arr = f(i, e)._array;
+      outLen   += arr.length;
+      temp[i]   = arr! as Array<B>;
     }
-    start += l;
-  }
-  return out.asImmutableArray;
+    const out = Array<B>(outLen);
+    let start = 0;
+    for (let i = 0; i < len; i++) {
+      const arr = temp[i]!;
+      const l   = arr.length;
+      for (let j = 0; j < l; j++) {
+        out[j + start] = arr[j]!;
+      }
+      start += l;
+    }
+    return out.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray flatMap
+ * @tsplus pipeable fncts.ImmutableArray flatMap
  */
-export function flatMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => ImmutableArray<B>): ImmutableArray<B> {
-  return self.flatMapWithIndex((_, a) => f(a));
+export function flatMap<A, B>(f: (a: A) => ImmutableArray<B>) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    return self.flatMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
@@ -185,38 +192,37 @@ export function flatten<A>(self: ImmutableArray<ImmutableArray<A>>): ImmutableAr
  * often used for "chopping" up the input `Array`. Typically chop is called with some function
  * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
  *
- * @tsplus fluent fncts.ImmutableArray chop
- */
-export function chop_<A, B>(
-  as: ImmutableArray<A>,
-  f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>],
-): ImmutableArray<B> {
-  const result: Array<B>    = [];
-  let cs: ImmutableArray<A> = as;
-  while (cs.isNonEmpty()) {
-    const [b, c] = f(cs);
-    result.push(b);
-    cs = c;
-  }
-  return result.asImmutableArray;
+ * @tsplus pipeable fncts.ImmutableArray chop
+ */
+export function chop<A, B>(f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]) {
+  return (as: ImmutableArray<A>): ImmutableArray<B> => {
+    const result: Array<B>    = [];
+    let cs: ImmutableArray<A> = as;
+    while (cs.isNonEmpty()) {
+      const [b, c] = f(cs);
+      result.push(b);
+      cs = c;
+    }
+    return result.asImmutableArray;
+  };
 }
 
-export const chop = Pipeable(chop_);
-
 /**
- * @tsplus fluent fncts.ImmutableArray collectWhile
+ * @tsplus pipeable fncts.ImmutableArray collectWhile
  */
-export function collectWhile_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B> {
-  const result: Array<B> = [];
-  for (let i = 0; i < as.length; i++) {
-    const o = f(as._array[i]!);
-    if (o.isJust()) {
-      result.push(o.value);
-    } else {
-      break;
+export function collectWhile<A, B>(f: (a: A) => Maybe<B>) {
+  return (as: ImmutableArray<A>): ImmutableArray<B> => {
+    const result: Array<B> = [];
+    for (let i = 0; i < as.length; i++) {
+      const o = f(as._array[i]!);
+      if (o.isJust()) {
+        result.push(o.value);
+      } else {
+        break;
+      }
     }
-  }
-  return result.asImmutableArray;
+    return result.asImmutableArray;
+  };
 }
 
 function comprehensionLoop<A, R>(
@@ -266,72 +272,82 @@ export function comprehension<A, R>(
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray concat
- * @tsplus operator fncts.ImmutableArray +
+ * @tsplus pipeable fncts.ImmutableArray concat
+ * @tsplus pipeable-operator fncts.ImmutableArray +
  */
-export function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<A | B> {
-  const lenx = self._array.length;
-  if (lenx === 0) {
-    return that;
-  }
-  const leny = that._array.length;
-  if (leny === 0) {
-    return self;
-  }
-  const r = Array<A | B>(lenx + leny);
-  for (let i = 0; i < lenx; i++) {
-    r[i] = self._array[i]!;
-  }
-  for (let i = 0; i < leny; i++) {
-    r[i + lenx] = that._array[i]!;
-  }
-  return r.asImmutableArray;
+export function concat<B>(that: ImmutableArray<B>) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A | B> => {
+    const lenx = self._array.length;
+    if (lenx === 0) {
+      return that;
+    }
+    const leny = that._array.length;
+    if (leny === 0) {
+      return self;
+    }
+    const r = Array<A | B>(lenx + leny);
+    for (let i = 0; i < lenx; i++) {
+      r[i] = self._array[i]!;
+    }
+    for (let i = 0; i < leny; i++) {
+      r[i + lenx] = that._array[i]!;
+    }
+    return r.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray deleteAt
+ * @tsplus pipeable fncts.ImmutableArray deleteAt
  */
-export function deleteAt_<A>(as: ImmutableArray<A>, i: number): Maybe<ImmutableArray<A>> {
-  return as.isOutOfBound(i) ? Nothing() : Just(as.unsafeDeleteAt(i));
+export function deleteAt(i: number) {
+  return <A>(as: ImmutableArray<A>): Maybe<ImmutableArray<A>> => {
+    return as.isOutOfBound(i) ? Nothing() : Just(as.unsafeDeleteAt(i));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray difference
+ * @tsplus pipeable fncts.ImmutableArray difference
  */
-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));
+export function difference<A>(ys: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.filter((a) => !ys.elem(a, E));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray drop
+ * @tsplus pipeable fncts.ImmutableArray drop
  */
-export function drop_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A> {
-  return self.slice(n);
+export function drop(n: number) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.slice(n);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray dropLast
+ * @tsplus pipeable fncts.ImmutableArray dropLast
  */
-export function dropLast_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A> {
-  return self.slice(0, self.length - n);
+export function dropLast(n: number) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.slice(0, self.length - n);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray dropWhile
+ * @tsplus pipeable fncts.ImmutableArray dropWhile
  */
-export function dropWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A> {
-  return self.slice(self.spanIndexLeft(p));
+export function dropWhile<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.slice(self.spanIndexLeft(p));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ * @tsplus pipeable fncts.ImmutableArray dropLastWhile
  */
-export function dropLastWhile_<A>(as: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A> {
-  return as.slice(0, as.spanIndexRight(p) + 1);
+export function dropLastWhile<A>(p: Predicate<A>) {
+  return (as: ImmutableArray<A>): ImmutableArray<A> => {
+    return as.slice(0, as.spanIndexRight(p) + 1);
+  };
 }
 
 /**
@@ -339,334 +355,383 @@ 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>`.
  *
- * @tsplus fluent fncts.ImmutableArray elem
- */
-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;
+ * @tsplus pipeable fncts.ImmutableArray elem
+ */
+export function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>) {
+  return (as: ImmutableArray<A>): boolean => {
+    const predicate = (element: A) => E.equals(a)(element);
+    const len       = as.length;
+    for (let i = 0; i < len; i++) {
+      if (predicate(as._array[i]!)) {
+        return true;
+      }
     }
-  }
-  return false;
+    return false;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray every
+ * @tsplus pipeable fncts.ImmutableArray every
  */
-export function every_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): self is ImmutableArray<B>;
-export function every_<A>(self: ImmutableArray<A>, p: Predicate<A>): boolean;
-export function every_<A>(self: ImmutableArray<A>, p: Predicate<A>): boolean {
-  return self.everyWithIndex((_, a) => p(a));
+export function every<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => self is ImmutableArray<B>;
+export function every<A>(p: Predicate<A>): (self: ImmutableArray<A>) => boolean;
+export function every<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): boolean => {
+    return self.everyWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray everyWithIndex
+ * @tsplus pipeable fncts.ImmutableArray everyWithIndex
  */
-export function everyWithIndex_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function everyWithIndex<A, B extends A>(
   p: RefinementWithIndex<number, A, B>,
-): self is ImmutableArray<B>;
-export function everyWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): boolean;
-export function everyWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): boolean {
-  let result = true;
-  let i      = 0;
-  while (result && i < self.length) {
-    result = p(i, self._array[i]!);
-    i++;
-  }
-  return result;
+): (self: ImmutableArray<A>) => self is ImmutableArray<B>;
+export function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => boolean;
+export function everyWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: ImmutableArray<A>): boolean => {
+    let result = true;
+    let i      = 0;
+    while (result && i < self.length) {
+      result = p(i, self._array[i]!);
+      i++;
+    }
+    return result;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray exists
+ * @tsplus pipeable fncts.ImmutableArray some
  */
-export function exists_<A>(self: ImmutableArray<A>, p: Predicate<A>): self is ImmutableNonEmptyArray<A> {
-  let result = false;
-  let i      = 0;
-  while (!result && i < self.length) {
-    result = p(self._array[i]!);
-    i++;
-  }
-  return result;
+export function some<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A> => {
+    let result = false;
+    let i      = 0;
+    while (!result && i < self.length) {
+      result = p(self._array[i]!);
+      i++;
+    }
+    return result;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray filter
+ * @tsplus pipeable fncts.ImmutableArray filter
  */
-export function filter_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
-export function filter_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
-export function filter_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A> {
-  return self.filterWithIndex((_, a) => p(a));
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export function filter<A>(p: Predicate<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+export function filter<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.filterWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray filterWithIndex
+ * @tsplus pipeable fncts.ImmutableArray filterWithIndex
  */
-export function filterWithIndex_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function filterWithIndex<A, B extends A>(
   p: RefinementWithIndex<number, A, B>,
-): ImmutableArray<B>;
-export function filterWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): ImmutableArray<A>;
-export function filterWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): ImmutableArray<A> {
-  const result: Array<A> = [];
-  for (let i = 0; i < self.length; i++) {
-    const a = self._array[i]!;
-    if (p(i, a)) {
-      result.push(a);
+): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+export function filterWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    const result: Array<A> = [];
+    for (let i = 0; i < self.length; i++) {
+      const a = self._array[i]!;
+      if (p(i, a)) {
+        result.push(a);
+      }
     }
-  }
-  return result.asImmutableArray;
+    return result.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray filterMapWithIndex
  */
-export function filterMapWithIndex_<A, B>(fa: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): ImmutableArray<B> {
-  const result = [];
-  for (let i = 0; i < fa.length; i++) {
-    const maybeB = f(i, fa[i]!);
-    if (maybeB.isJust()) {
-      result.push(maybeB.value);
+export function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>) {
+  return (fa: ImmutableArray<A>): ImmutableArray<B> => {
+    const result = [];
+    for (let i = 0; i < fa.length; i++) {
+      const maybeB = f(i, fa[i]!);
+      if (maybeB.isJust()) {
+        result.push(maybeB.value);
+      }
     }
-  }
-  return result.asImmutableArray;
+    return result.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray filterMap
+ * @tsplus pipeable fncts.ImmutableArray filterMap
  */
-export function filterMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B> {
-  return self.filterMapWithIndex((_, a) => f(a));
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    return self.filterMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray find
+ * @tsplus pipeable fncts.ImmutableArray find
  */
-export function find_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
-export function find_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
-export function find_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<A> {
-  return self.findWithIndex((_, a) => p(a));
+export function find<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => Maybe<B>;
+export function find<A>(p: Predicate<A>): (self: ImmutableArray<A>) => Maybe<A>;
+export function find<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): Maybe<A> => {
+    return self.findWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findIndex
+ * @tsplus pipeable fncts.ImmutableArray findIndex
  */
-export function findIndex_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): Maybe<number> {
-  return as.findMapWithIndex((i, a) => (predicate(a) ? Just(i) : Nothing()));
+export function findIndex<A>(predicate: Predicate<A>) {
+  return (as: ImmutableArray<A>): Maybe<number> => {
+    return as.findMapWithIndex((i, a) => (predicate(a) ? Just(i) : Nothing()));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findWithIndex
  */
-export function findWithIndex_<A, B extends A>(as: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): Maybe<B>;
-export function findWithIndex_<A>(as: ImmutableArray<A>, p: PredicateWithIndex<number, A>): Maybe<A>;
-export function findWithIndex_<A>(as: ImmutableArray<A>, p: PredicateWithIndex<number, A>): Maybe<A> {
-  const len = as.length;
-  for (let i = 0; i < len; i++) {
-    if (p(i, as._array[i]!)) {
-      return Just(as._array[i]!);
+export function findWithIndex<A, B extends A>(
+  p: RefinementWithIndex<number, A, B>,
+): (as: ImmutableArray<A>) => Maybe<B>;
+export function findWithIndex<A>(p: PredicateWithIndex<number, A>): (as: ImmutableArray<A>) => Maybe<A>;
+export function findWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (as: ImmutableArray<A>): Maybe<A> => {
+    const len = as.length;
+    for (let i = 0; i < len; i++) {
+      if (p(i, as._array[i]!)) {
+        return Just(as._array[i]!);
+      }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findMap
+ * @tsplus pipeable fncts.ImmutableArray findMap
  */
-export function findMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  return as.findMapWithIndex((_, a) => f(a));
+export function findMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (as: ImmutableArray<A>): Maybe<B> => {
+    return as.findMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findMapWithIndex
  */
-export function findMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (index: number, a: A) => Maybe<B>): Maybe<B> {
-  const len = as.length;
-  for (let i = 0; i < len; i++) {
-    const v = f(i, as._array[i]!);
-    if (v.isJust()) {
-      return v;
+export function findMapWithIndex<A, B>(f: (index: number, a: A) => Maybe<B>) {
+  return (as: ImmutableArray<A>): Maybe<B> => {
+    const len = as.length;
+    for (let i = 0; i < len; i++) {
+      const v = f(i, as._array[i]!);
+      if (v.isJust()) {
+        return v;
+      }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findLast
+ * @tsplus pipeable fncts.ImmutableArray findLast
  */
-export function findLast_<A, B extends A>(as: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
-export function findLast_<A>(as: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
-export function findLast_<A>(as: ImmutableArray<A>, p: Predicate<A>): Maybe<A> {
-  const len = as.length;
-  for (let i = len - 1; i >= 0; i--) {
-    if (p(as._array[i]!)) {
-      return Just(as._array[i]!);
+export function findLast<A, B extends A>(p: Refinement<A, B>): (as: ImmutableArray<A>) => Maybe<B>;
+export function findLast<A>(p: Predicate<A>): (as: ImmutableArray<A>) => Maybe<A>;
+export function findLast<A>(p: Predicate<A>) {
+  return (as: ImmutableArray<A>): Maybe<A> => {
+    const len = as.length;
+    for (let i = len - 1; i >= 0; i--) {
+      if (p(as._array[i]!)) {
+        return Just(as._array[i]!);
+      }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findLastIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastIndex
  */
-export function findLastIndex_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<number> {
-  return self.findLastMapWithIndex((i, a) => (p(a) ? Just(i) : Nothing()));
+export function findLastIndex<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): Maybe<number> => {
+    return self.findLastMapWithIndex((i, a) => (p(a) ? Just(i) : Nothing()));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMap
+ * @tsplus pipeable fncts.ImmutableArray findLastMap
  */
-export function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B> {
-  return as.findLastMapWithIndex((_, a) => f(a));
+export function findLastMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (as: ImmutableArray<A>): Maybe<B> => {
+    return as.findLastMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastMapWithIndex
  */
-export function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B> {
-  const len = as.length;
-  for (let i = len - 1; i >= 0; i--) {
-    const v = f(i, as._array[i]!);
-    if (v.isJust()) {
-      return v;
+export function findLastMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>) {
+  return (as: ImmutableArray<A>): Maybe<B> => {
+    const len = as.length;
+    for (let i = len - 1; i >= 0; i--) {
+      const v = f(i, as._array[i]!);
+      if (v.isJust()) {
+        return v;
+      }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.MutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndex
  */
-export function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B {
-  const len = self.length;
-  let r     = b;
-  for (let i = 0; i < len; i++) {
-    r = f(i, r, self._array[i]!);
-  }
-  return r;
+export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
+  return (self: ImmutableArray<A>): B => {
+    const len = self.length;
+    let r     = b;
+    for (let i = 0; i < len; i++) {
+      r = f(i, r, self._array[i]!);
+    }
+    return r;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.MutableArray foldLeft
+ * @tsplus pipeable fncts.ImmutableArray foldLeft
+ * @tsplus pipeable fncts.MutableArray foldLeft
  */
-export function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B {
-  return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: ImmutableArray<A>): B => {
+    return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.MutableArray foldLeftWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWhile
  */
-export function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B {
-  return self.foldLeftWithIndexWhile(b, p, (_, b, a) => f(b, a));
+export function foldLeftWhile<A, B>(b: B, p: Predicate<B>, f: (b: B, a: A) => B) {
+  return (self: ImmutableArray<A>): B => {
+    return self.foldLeftWithIndexWhile(b, p, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndexWhile
  */
-export function foldLeftWithIndexWhile_<A, B>(
-  self: ImmutableArray<A>,
-  b: B,
-  p: Predicate<B>,
-  f: (i: number, b: B, a: A) => B,
-): B {
-  let out  = b;
-  let cont = p(out);
-  for (let i = 0; cont && i < self.length; i++) {
-    out  = f(i, out, self._array[i]!);
-    cont = p(out);
-  }
-  return out;
+export function foldLeftWithIndexWhile<A, B>(b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B) {
+  return (self: ImmutableArray<A>): B => {
+    let out  = b;
+    let cont = p(out);
+    for (let i = 0; cont && i < self.length; i++) {
+      out  = f(i, out, self._array[i]!);
+      cont = p(out);
+    }
+    return out;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus pipeable fncts.ImmutableArray fold
  */
-export function fold<M>(self: ImmutableArray<M>, /** @tsplus auto */ M: Monoid<M>): M {
-  return self.foldLeft(M.nat, M.combine);
+export function fold<M>(/** @tsplus auto */ M: Monoid<M>) {
+  return (self: ImmutableArray<M>): M => {
+    return self.foldLeft(M.nat, (b, a) => M.combine(a)(b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldMapWithIndex
  */
-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)));
+export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: ImmutableArray<A>): M => {
+    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldMap
+ * @tsplus pipeable fncts.ImmutableArray foldMap
  */
-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);
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: ImmutableArray<A>): M => {
+    return self.foldMapWithIndex((_, a) => f(a), M);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndex
  */
-export function foldRightWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, a: A, b: B) => B): B {
-  let r = b;
-  for (let i = self.length - 1; i >= 0; i--) {
-    r = f(i, self._array[i]!, r);
-  }
-  return r;
+export function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B) {
+  return (self: ImmutableArray<A>): B => {
+    let r = b;
+    for (let i = self.length - 1; i >= 0; i--) {
+      r = f(i, self._array[i]!, r);
+    }
+    return r;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus pipeable fncts.ImmutableArray 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));
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: ImmutableArray<A>): B => {
+    return self.foldRightWithIndex(b, (_, a, b) => f(a, b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRighWhile
  */
-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));
+export function foldRightWhile<A, B>(b: B, p: Predicate<B>, f: (a: A, b: B) => B) {
+  return (self: ImmutableArray<A>): B => {
+    return self.foldRightWithIndexWhile(b, p, (_, a, b) => f(a, b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndexWhile
  */
-export function foldRightWithIndexWhile_<A, B>(
-  self: ImmutableArray<A>,
-  b: B,
-  predicate: Predicate<B>,
-  f: (i: number, a: A, b: B) => B,
-): B {
-  let out  = b;
-  let cont = predicate(out);
-  for (let i = self.length - 1; cont && i >= 0; i--) {
-    out  = f(i, self._array[i]!, out);
-    cont = predicate(out);
-  }
-  return out;
+export function foldRightWithIndexWhile<A, B>(b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B) {
+  return (self: ImmutableArray<A>): B => {
+    let out  = b;
+    let cont = predicate(out);
+    for (let i = self.length - 1; cont && i >= 0; i--) {
+      out  = f(i, self._array[i]!, out);
+      cont = predicate(out);
+    }
+    return out;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray forEach
+ * @tsplus pipeable fncts.ImmutableArray forEach
  */
-export function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void {
-  return self.forEach(f);
+export function forEach<A, B>(f: (a: A) => B) {
+  return (self: ImmutableArray<A>): void => {
+    return self.forEach(f);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.MutableArray get
+ * @tsplus pipeable fncts.ImmutableArray get
+ * @tsplus pipeable fncts.MutableArray get
  */
-export function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A> {
-  return self.isOutOfBound(i) ? Nothing() : Just(self._array[i]!);
+export function get(i: number) {
+  return <A>(self: ImmutableArray<A>): Maybe<A> => {
+    return self.isOutOfBound(i) ? Nothing() : Just(self._array[i]!);
+  };
 }
 
+/**
+ * @tsplus pipeable fncts.ImmutableArray group
+ */
 export function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<ImmutableNonEmptyArray<A>> {
   return chop((self) => {
     const h   = self._array[0]!;
@@ -674,7 +739,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(h)(a)) {
         out.push(a);
       } else {
         break;
@@ -685,30 +750,22 @@ export function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArra
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray group
+ * @tsplus pipeable fncts.ImmutableArray groupBy
  */
-export function chopSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<ImmutableNonEmptyArray<A>> {
-  return group(E)(self);
-}
-
-/**
- * @tsplus fluent fncts.ImmutableArray groupBy
- */
-export function groupBy_<A>(
-  self: ImmutableArray<A>,
-  f: (a: A) => string,
-): Readonly<Record<string, ImmutableNonEmptyArray<A>>> {
-  const out: Record<string, NonEmptyArray<A>> = {};
-  for (let i = 0; i < self.length; i++) {
-    const a = self._array[i]!;
-    const k = f(a);
-    if (Object.prototype.hasOwnProperty.call(out, k)) {
-      out[k]!.push(a);
-    } else {
-      out[k] = [a];
+export function groupBy<A>(f: (a: A) => string) {
+  return (self: ImmutableArray<A>): Readonly<Record<string, ImmutableNonEmptyArray<A>>> => {
+    const out: Record<string, NonEmptyArray<A>> = {};
+    for (let i = 0; i < self.length; i++) {
+      const a = self._array[i]!;
+      const k = f(a);
+      if (Object.prototype.hasOwnProperty.call(out, k)) {
+        out[k]!.push(a);
+      } else {
+        out[k] = [a];
+      }
     }
-  }
-  return Dictionary.get(out).map(ImmutableNonEmptyArray.from).toRecord;
+    return Dictionary.get(out).map(ImmutableNonEmptyArray.from).toRecord;
+  };
 }
 
 /**
@@ -727,26 +784,31 @@ export function init<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>> {
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray insertAt
+ * @tsplus pipeable fncts.ImmutableArray insertAt
  */
-export function insertAt_<A>(self: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableNonEmptyArray<A>> {
-  return self.isOutOfBound(i) ? Nothing() : Just(self.unsafeInsertAt(i, a));
+export function insertAt<A>(i: number, a: A) {
+  return (self: ImmutableArray<A>): Maybe<ImmutableNonEmptyArray<A>> => {
+    return self.isOutOfBound(i) ? Nothing() : Just(self.unsafeInsertAt(i, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray intersection
+ * @tsplus pipeable fncts.ImmutableArray intersection
  */
-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 intersection<A>(that: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.filter((a) => that.elem(a, E));
+  };
 }
 
-export function intersperse_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A> {
-  const len = self.length;
-  return len === 0 ? self : self.slice(1, len).prependAll(a).prepend(self[0]!);
+/**
+ * @tsplus pipeable fncts.ImmutableArray intersperse
+ */
+export function intersperse<A>(a: A) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    const len = self.length;
+    return len === 0 ? self : self.slice(1, len).prependAll(a).prepend(self[0]!);
+  };
 }
 
 /**
@@ -757,17 +819,21 @@ export function isEmpty<A>(self: ImmutableArray<A>): boolean {
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ * @tsplus pipeable fncts.ImmutableArray isOutOfBound
  */
-export function isOutOfBound_<A>(self: ImmutableArray<A>, i: number): boolean {
-  return i < 0 || i >= self.length;
+export function isOutOfBound(i: number) {
+  return <A>(self: ImmutableArray<A>): boolean => {
+    return i < 0 || i >= self.length;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray join
+ * @tsplus pipeable fncts.ImmutableArray join
  */
-export function join(self: ImmutableArray<string>, separator: string): string {
-  return self._array.join(separator);
+export function join(separator: string) {
+  return (self: ImmutableArray<string>): string => {
+    return self._array.join(separator);
+  };
 }
 
 /**
@@ -800,56 +866,62 @@ export function lefts<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray map
+ * @tsplus pipeable fncts.ImmutableArray map
  */
-export function map_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): ImmutableArray<B> {
-  return self.mapWithIndex((_, a) => f(a));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    return self.mapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray mapAccum
+ * @tsplus pipeable fncts.ImmutableArray mapAccum
  */
-export function mapAccum_<A, S, B>(
-  self: ImmutableArray<A>,
-  s: S,
-  f: (s: S, a: A) => readonly [B, S],
-): readonly [ImmutableArray<B>, S] {
-  const bs  = Array<B>(self.length);
-  let state = s;
-  for (let i = 0; i < self.length; i++) {
-    const result = f(state, self._array[i]!);
-    bs[i]        = result[0];
-    state        = result[1];
-  }
-  return [bs.asImmutableArray, state];
+export function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<B>, S] => {
+    const bs  = Array<B>(self.length);
+    let state = s;
+    for (let i = 0; i < self.length; i++) {
+      const result = f(state, self._array[i]!);
+      bs[i]        = result[0];
+      state        = result[1];
+    }
+    return [bs.asImmutableArray, state];
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray mapWithIndex
  */
-export function mapWithIndex_<A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => B): ImmutableArray<B> {
-  const len = self._array.length;
-  const bs  = Array<B>(len);
-  for (let i = 0; i < len; i++) {
-    bs[i] = f(i, self._array[i]!);
-  }
-  return bs.asImmutableArray;
+export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    const len = self._array.length;
+    const bs  = Array<B>(len);
+    for (let i = 0; i < len; i++) {
+      bs[i] = f(i, self._array[i]!);
+    }
+    return bs.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray modifyAt
+ * @tsplus pipeable fncts.ImmutableArray modifyAt
  */
-export function modifyAt_<A>(self: ImmutableArray<A>, i: number, f: (a: A) => A): Maybe<ImmutableArray<A>> {
-  return self.isOutOfBound(i) ? Nothing() : Just(self.unsafeModifyAt(i, f));
+export function modifyAt<A>(i: number, f: (a: A) => A) {
+  return (self: ImmutableArray<A>): Maybe<ImmutableArray<A>> => {
+    return self.isOutOfBound(i) ? Nothing() : Just(self.unsafeModifyAt(i, f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray mutate
+ * @tsplus pipeable fncts.ImmutableArray mutate
  */
-export function mutate_<A>(self: ImmutableArray<A>, f: (self: Array<A>) => void): ImmutableArray<A> {
-  const mut = mutableClone(self);
-  f(mut);
-  return mut.asImmutableArray;
+export function mutate<A>(f: (self: Array<A>) => void) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    const mut = mutableClone(self);
+    f(mut);
+    return mut.asImmutableArray;
+  };
 }
 
 /**
@@ -860,108 +932,103 @@ export function mutableClone<A>(self: ImmutableArray<A>): Array<A> {
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray partitionWithIndex
+ * @tsplus pipeable fncts.ImmutableArray partitionWithIndex
  */
-export function partitionWithIndex_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function partitionWithIndex<A, B extends A>(
   p: RefinementWithIndex<number, A, B>,
-): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export function partitionWithIndex_<A>(
-  self: ImmutableArray<A>,
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export function partitionWithIndex<A>(
   p: PredicateWithIndex<number, A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>];
-export function partitionWithIndex_<A>(
-  self: ImmutableArray<A>,
-  p: PredicateWithIndex<number, A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  const left: Array<A>  = [];
-  const right: Array<A> = [];
-  for (let i = 0; i < self.length; i++) {
-    const a = self._array[i]!;
-    if (p(i, a)) {
-      right.push(a);
-    } else {
-      left.push(a);
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
+export function partitionWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<A>, ImmutableArray<A>] => {
+    const left: Array<A>  = [];
+    const right: Array<A> = [];
+    for (let i = 0; i < self.length; i++) {
+      const a = self._array[i]!;
+      if (p(i, a)) {
+        right.push(a);
+      } else {
+        left.push(a);
+      }
     }
-  }
-  return [left.asImmutableArray, right.asImmutableArray];
+    return [left.asImmutableArray, right.asImmutableArray];
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray partition
+ * @tsplus pipeable fncts.ImmutableArray partition
  */
-export function partition_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function partition<A, B extends A>(
   p: Refinement<A, B>,
-): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export function partition_<A>(
-  self: ImmutableArray<A>,
-  p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>];
-export function partition_<A>(
-  self: ImmutableArray<A>,
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export function partition<A>(
   p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  return self.partitionWithIndex((_, a) => p(a));
-}
-
-/**
- * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
- */
-export function partitionMapWithIndex_<A, B, C>(
-  self: ImmutableArray<A>,
-  f: (i: number, a: A) => Either<B, C>,
-): readonly [ImmutableArray<B>, ImmutableArray<C>] {
-  const left  = [] as Array<B>;
-  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);
-        break;
-      case EitherTag.Right:
-        right.push(ea.right);
-        break;
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
+export function partition<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<A>, ImmutableArray<A>] => {
+    return self.partitionWithIndex((_, a) => p(a));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.ImmutableArray partitionMapWithIndex
+ */
+export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<B>, ImmutableArray<C>] => {
+    const left  = [] as Array<B>;
+    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);
+          break;
+        case EitherTag.Right:
+          right.push(ea.right);
+          break;
+      }
     }
-  }
-  return [left.asImmutableArray, right.asImmutableArray];
+    return [left.asImmutableArray, right.asImmutableArray];
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray partitionMap
+ * @tsplus pipeable fncts.ImmutableArray partitionMap
  */
-export function partitionMap_<A, B, C>(
-  self: ImmutableArray<A>,
-  f: (a: A) => Either<B, C>,
-): readonly [ImmutableArray<B>, ImmutableArray<C>] {
-  return self.partitionMapWithIndex((_, a) => f(a));
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<B>, ImmutableArray<C>] => {
+    return self.partitionMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray prepend
+ * @tsplus pipeable fncts.ImmutableArray prepend
  */
-export function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B> {
-  const len = self.length;
-  const out = Array<A | B>(len + 1);
-  out[0]    = head;
-  for (let i = 0; i < len; i++) {
-    out[i + 1] = self._array[i]!;
-  }
-  return out.asImmutableArray;
+export function prepend<B>(head: B) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A | B> => {
+    const len = self.length;
+    const out = Array<A | B>(len + 1);
+    out[0]    = head;
+    for (let i = 0; i < len; i++) {
+      out[i + 1] = self._array[i]!;
+    }
+    return out.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.MutableArray prependAll
+ * @tsplus pipeable fncts.ImmutableArray prependAll
  */
-export function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A> {
-  const out: Array<A> = [];
-  for (let i = 0; i < self.length; i++) {
-    out.push(a, self._array[i]!);
-  }
-  return out.asImmutableArray;
+export function prependAll<A>(a: A) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    const out: Array<A> = [];
+    for (let i = 0; i < self.length; i++) {
+      out.push(a, self._array[i]!);
+    }
+    return out.asImmutableArray;
+  };
 }
 
 /**
@@ -997,137 +1064,150 @@ export function rights<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray rotate
+ * @tsplus pipeable fncts.ImmutableArray rotate
  */
-export function rotate_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A> {
-  const len = self.length;
-  if (n === 0 || len <= 1 || len === Math.abs(n)) {
-    return self;
-  } else if (n < 0) {
-    return self.rotate(len + n);
-  } else {
-    return self.slice(-n).concat(self.slice(0, len - n));
-  }
+export function rotate(n: number) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A> => {
+    const len = self.length;
+    if (n === 0 || len <= 1 || len === Math.abs(n)) {
+      return self;
+    } else if (n < 0) {
+      return self.rotate(len + n);
+    } else {
+      return self.slice(-n).concat(self.slice(0, len - n));
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray scanLeft
+ * @tsplus pipeable fncts.ImmutableArray scanLeft
  */
-export function scanLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): ImmutableArray<B> {
-  const l = self.length;
-  const r = Array(l + 1);
-  r[0]    = b;
-  for (let i = 0; i < l; i++) {
-    r[i + 1] = f(r[i]!, self._array[i]!);
-  }
-  return r.asImmutableArray;
+export function scanLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    const l = self.length;
+    const r = Array(l + 1);
+    r[0]    = b;
+    for (let i = 0; i < l; i++) {
+      r[i + 1] = f(r[i]!, self._array[i]!);
+    }
+    return r.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray scanRight
+ * @tsplus pipeable fncts.ImmutableArray scanRight
  */
-export function scanRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): ImmutableArray<B> {
-  const l = self.length;
-  const r = Array(l + 1);
-  r[l]    = b;
-  for (let i = l - 1; i >= 0; i--) {
-    r[i] = f(self._array[i]!, r[i + 1]!);
-  }
-  return r.asImmutableArray;
+export function scanRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return (self: ImmutableArray<A>): ImmutableArray<B> => {
+    const l = self.length;
+    const r = Array(l + 1);
+    r[l]    = b;
+    for (let i = l - 1; i >= 0; i--) {
+      r[i] = f(self._array[i]!, r[i + 1]!);
+    }
+    return r.asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray sort
+ * @tsplus pipeable fncts.ImmutableArray sort
  */
-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;
+export function sort<A>(/** @tsplus auto */ O: P.Ord<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.isEmpty() || self.length === 1
+      ? self
+      : self._array.slice().sort((a, b) => O.compare(b)(a)).asImmutableArray;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray sortBy
+ * @tsplus pipeable fncts.ImmutableArray sortBy
  */
-export function sortBy<A>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<A>>): ImmutableArray<A> {
-  return self.sort(Os.fold(P.Ord.getMonoid()));
+export function sortBy<A>(Os: ImmutableArray<P.Ord<A>>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.sort(Os.fold(P.Ord.getMonoid()));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray spanLeft
+ * @tsplus pipeable fncts.ImmutableArray spanLeft
  */
-export function spanLeft_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function spanLeft<A, B extends A>(
   p: Refinement<A, B>,
-): readonly [ImmutableArray<B>, ImmutableArray<A>];
-export function spanLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
-export function spanLeft_<A>(
-  self: ImmutableArray<A>,
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<B>, ImmutableArray<A>];
+export function spanLeft<A>(
   p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  const i    = self.spanIndexLeft(p);
-  const init = Array<A>(i);
-  for (let j = 0; j < i; j++) {
-    init[j] = self._array[j]!;
-  }
-  const l    = self.length;
-  const rest = Array<A>(l - i);
-  for (let j = i; j < l; j++) {
-    rest[j - i] = self._array[j]!;
-  }
-  return [init.asImmutableArray, rest.asImmutableArray];
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
+export function spanLeft<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<A>, ImmutableArray<A>] => {
+    const i    = self.spanIndexLeft(p);
+    const init = Array<A>(i);
+    for (let j = 0; j < i; j++) {
+      init[j] = self._array[j]!;
+    }
+    const l    = self.length;
+    const rest = Array<A>(l - i);
+    for (let j = i; j < l; j++) {
+      rest[j - i] = self._array[j]!;
+    }
+    return [init.asImmutableArray, rest.asImmutableArray];
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray spanRight
+ * @tsplus pipeable fncts.ImmutableArray spanRight
  */
-export function spanRight_<A, B extends A>(
-  self: ImmutableArray<A>,
+export function spanRight<A, B extends A>(
   p: Refinement<A, B>,
-): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export function spanRight_<A>(
-  self: ImmutableArray<A>,
-  p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>];
-export function spanRight_<A>(
-  self: ImmutableArray<A>,
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export function spanRight<A>(
   p: Predicate<A>,
-): readonly [ImmutableArray<A>, ImmutableArray<A>] {
-  const i    = self.spanIndexRight(p);
-  const l    = self.length;
-  const tail = Array<A>(l - i - 1);
-  for (let j = l - 1; j > i; j--) {
-    tail[j - i - 1] = self._array[j]!;
-  }
-  const rest = Array<A>(i);
-  for (let j = i; j >= 0; j--) {
-    rest[j] = self._array[j]!;
-  }
-  return [rest.asImmutableArray, tail.asImmutableArray];
+): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
+export function spanRight<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): readonly [ImmutableArray<A>, ImmutableArray<A>] => {
+    const i    = self.spanIndexRight(p);
+    const l    = self.length;
+    const tail = Array<A>(l - i - 1);
+    for (let j = l - 1; j > i; j--) {
+      tail[j - i - 1] = self._array[j]!;
+    }
+    const rest = Array<A>(i);
+    for (let j = i; j >= 0; j--) {
+      rest[j] = self._array[j]!;
+    }
+    return [rest.asImmutableArray, tail.asImmutableArray];
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ * @tsplus pipeable fncts.ImmutableArray spanIndexLeft
  */
-export function spanIndexLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): number {
-  const l = self.length;
-  let i   = 0;
-  for (; i < l; i++) {
-    if (!p(self._array[i]!)) {
-      break;
+export function spanIndexLeft<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): number => {
+    const l = self.length;
+    let i   = 0;
+    for (; i < l; i++) {
+      if (!p(self._array[i]!)) {
+        break;
+      }
     }
-  }
-  return i;
+    return i;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ * @tsplus pipeable fncts.ImmutableArray spanIndexRight
  */
-export function spanIndexRight_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): number {
-  let i = as.length - 1;
-  for (; i >= 0; i--) {
-    if (!predicate(as._array[i]!)) {
-      break;
+export function spanIndexRight<A>(predicate: Predicate<A>) {
+  return (as: ImmutableArray<A>): number => {
+    let i = as.length - 1;
+    for (; i >= 0; i--) {
+      if (!predicate(as._array[i]!)) {
+        break;
+      }
     }
-  }
-  return i;
+    return i;
+  };
 }
 
 /**
@@ -1138,76 +1218,107 @@ export function tail<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>> {
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray take
+ * @tsplus pipeable fncts.ImmutableArray take
  */
-export function take_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A> {
-  return self.slice(0, n);
+export function take(n: number) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.slice(0, n);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray takeLast
+ * @tsplus pipeable fncts.ImmutableArray takeLast
  */
-export function takeLast_<A>(as: ImmutableArray<A>, n: number): ImmutableArray<A> {
-  return isEmpty(as) ? ImmutableArray.empty() : as.slice(-n);
+export function takeLast(n: number) {
+  return <A>(as: ImmutableArray<A>): ImmutableArray<A> => {
+    return isEmpty(as) ? ImmutableArray.empty() : as.slice(-n);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray takeWhile
+ * @tsplus pipeable fncts.ImmutableArray takeWhile
  */
-export function takeWhile_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
-export function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
-export function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A> {
-  const i    = self.spanIndexLeft(p);
-  const init = Array<A>(i);
-  for (let j = 0; j < i; j++) {
-    init[j] = self._array[j]!;
-  }
-  return init.asImmutableArray;
+export function takeWhile<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export function takeWhile<A>(p: Predicate<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+export function takeWhile<A>(p: Predicate<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    const i    = self.spanIndexLeft(p);
+    const init = Array<A>(i);
+    for (let j = 0; j < i; j++) {
+      init[j] = self._array[j]!;
+    }
+    return init.asImmutableArray;
+  };
 }
 
 /**
  * @tsplus getter fncts.ImmutableArray traverseWithIndex
  */
-export const traverseWithIndex_ = P.TraversableWithIndex.makeTraverseWithIndex<ImmutableArrayF>()(
-  () => (ta) => (G) => (f) =>
-    ta.foldLeftWithIndex(G.pure(ImmutableArray.empty()), (i, fbs, a) =>
-      G.zipWith(fbs, f(i, a), (bs, b) => bs.append(b)),
-    ),
-);
+export function _traverseWithIndex<A>(
+  self: ImmutableArray<A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K, Q, W, X, I, S, R, E, B>(
+  f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>,
+) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>>;
+export function _traverseWithIndex<A>(
+  self: ImmutableArray<A>,
+): <G>(G: P.Applicative<HKT.F<G>>) => <B>(f: (i: number, a: A) => HKT.FK1<G, B>) => HKT.FK1<G, ImmutableArray<B>> {
+  return (G) => (f) =>
+    self.foldLeftWithIndex(G.pure(ImmutableArray.empty()), (i, fbs, a) =>
+      pipe(
+        fbs,
+        G.zipWith(f(i, a), (bs, b) => bs.append(b)),
+      ),
+    );
+}
 
 /**
  * @tsplus getter fncts.ImmutableArray traverse
  */
-export const traverse_: P.Traversable<ImmutableArrayF>["traverse"] = (self) => (G) => (f) =>
+export function _traverse<A>(
+  self: ImmutableArray<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, ImmutableArray<B>> {
+  return (G) => (f) => self.traverseWithIndex(G)((_, a) => f(a));
+}
+
+export const traverseWithIndex: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"] = (G) => (f) => (self) =>
+  self.traverseWithIndex(G)(f);
+
+export const traverse: P.Traversable<ImmutableArrayF>["traverse"] = (G) => (f) => (self) =>
   self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.ImmutableArray union
+ * @tsplus pipeable fncts.ImmutableArray union
  */
-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)));
+export function union<A>(that: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.concat(that.filter((a) => !self.elem(a, E)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray uniq
+ * @tsplus pipeable fncts.ImmutableArray uniq
  */
-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);
+export function uniq<A>(/** @tsplus auto */ E: P.Eq<A>) {
+  return (self: ImmutableArray<A>): ImmutableArray<A> => {
+    if (self.length === 1) {
+      return self;
     }
-  }
-  return out.asImmutableArray;
+    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;
+  };
 }
 
 /**
@@ -1232,47 +1343,55 @@ export function unsafeAsMutable<A>(self: ImmutableArray<A>): Array<A> {
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeDeleteAt
  */
-export function unsafeDeleteAt_<A>(self: ImmutableArray<A>, i: number): ImmutableArray<A> {
-  return self.mutate((xs) => {
-    xs.splice(i, 1);
-  });
+export function unsafeDeleteAt(i: number) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<A> => {
+    return self.mutate((xs) => {
+      xs.splice(i, 1);
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeInsertAt
  */
-export function unsafeInsertAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableNonEmptyArray<A> {
-  return as.mutate((xs) => {
-    xs.splice(i, 0, a);
-  }) as unknown as ImmutableNonEmptyArray<A>;
+export function unsafeInsertAt<A>(i: number, a: A) {
+  return (as: ImmutableArray<A>): ImmutableNonEmptyArray<A> => {
+    return as.mutate((xs) => {
+      xs.splice(i, 0, a);
+    }) as unknown as ImmutableNonEmptyArray<A>;
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeModifyAt
  */
-export function unsafeModifyAt_<A>(as: ImmutableArray<A>, i: number, f: (a: A) => A): ImmutableArray<A> {
-  const next = f(as[i]!);
-  if (as[i] === next) {
-    return as;
-  }
-  return as.mutate((xs) => {
-    xs[i] = next;
-  });
+export function unsafeModifyAt<A>(i: number, f: (a: A) => A) {
+  return (as: ImmutableArray<A>): ImmutableArray<A> => {
+    const next = f(as[i]!);
+    if (as[i] === next) {
+      return as;
+    }
+    return as.mutate((xs) => {
+      xs[i] = next;
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeUpdateAt
  */
-export function unsafeUpdateAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableArray<A> {
-  if (as[i] === a) {
-    return as;
-  } else {
-    return as.mutate((xs) => {
-      xs[i] = a;
-    });
-  }
+export function unsafeUpdateAt<A>(i: number, a: A) {
+  return (as: ImmutableArray<A>): ImmutableArray<A> => {
+    if (as[i] === a) {
+      return as;
+    } else {
+      return as.mutate((xs) => {
+        xs[i] = a;
+      });
+    }
+  };
 }
 
 /**
@@ -1291,86 +1410,117 @@ export function unzip<A, B>(self: ImmutableArray<readonly [A, B]>): readonly [Im
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray updateAt
+ * @tsplus pipeable fncts.ImmutableArray updateAt
  */
-export function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableArray<A>> {
-  return as.isOutOfBound(i) ? Nothing() : Just(as.unsafeUpdateAt(i, a));
+export function updateAt<A>(i: number, a: A) {
+  return (as: ImmutableArray<A>): Maybe<ImmutableArray<A>> => {
+    return as.isOutOfBound(i) ? Nothing() : Just(as.unsafeUpdateAt(i, a));
+  };
 }
 
 /**
  * @tsplus getter fncts.ImmutableArray wiltWithIndex
  */
-export const wiltWithIndex = P.WitherableWithIndex.makeWiltWithIndex<ImmutableArrayF>()(
-  (_) => (self) => (G) => (f) =>
-    G.map(
-      self.foldLeftWithIndex(G.pure([[] as Array<typeof _["B"]>, [] as Array<typeof _["B1"]>] as const), (i, fbs, a) =>
-        G.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 _wiltWithIndex<A>(self: ImmutableArray<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E, B, B2>(
+      f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]> =>
+      self
+        .foldLeftWithIndex(G.pure([[] as Array<B>, [] as Array<B2>] as const), (i, fbs, a) =>
+          f(i, a).pipe(
+            G.zipWith(fbs, (eb, r) =>
+              eb.match(
+                (b1) => {
+                  r[0].push(b1);
+                  return r;
+                },
+                (b2) => {
+                  r[1].push(b2);
+                  return r;
+                },
+              ),
+            ),
           ),
-        ),
-      ),
-      ([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray],
-    ),
-);
+        )
+        .pipe(G.map(([b1s, b2s]) => [b1s.asImmutableArray, b2s.asImmutableArray]));
+}
 
 /**
  * @tsplus getter fncts.ImmutableArray wilt
  */
-export const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"] = (self) => (G) => (f) =>
-  self.wiltWithIndex(G)((_, a) => f(a));
+export function _wilt<A>(self: ImmutableArray<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E, B, B2>(
+      f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]> =>
+      self.wiltWithIndex(G)((_, a) => f(a));
+}
 
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  */
-export const witherWithIndex = P.WitherableWithIndex.makeWitherWithIndex<ImmutableArrayF>()(
-  (_) => (self) => (G) => (f) => {
-    return G.map(
-      self.foldLeftWithIndex(G.pure([] as Array<typeof _["B"]>), (i, b, a) =>
-        G.zipWith(f(i, a), b, (maybeB, bs) => {
-          if (maybeB.isJust()) {
-            bs.push(maybeB.value);
-          }
-          return bs;
-        }),
-      ),
-      (bs) => bs.asImmutableArray,
-    );
-  },
-);
+export function _witherWithIndex<A>(self: ImmutableArray<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E, B>(
+      f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Maybe<B>>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>> =>
+      self
+        .foldLeftWithIndex(G.pure([] as Array<B>), (i, b, a) =>
+          f(i, a).pipe(
+            G.zipWith(b, (maybeB, bs) => {
+              if (maybeB.isJust()) {
+                bs.push(maybeB.value);
+              }
+              return bs;
+            }),
+          ),
+        )
+        .pipe(G.map((bs) => bs.asImmutableArray));
+}
 
 /**
  * @tsplus getter fncts.ImmutableArray wither
  */
-export const wither: P.Witherable<ImmutableArrayF>["wither"] = (self) => (G) => (f) =>
+export function _wither<A>(self: ImmutableArray<A>) {
+  return <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, Maybe<B>>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>> =>
+      self.witherWithIndex(G)((_, a) => f(a));
+}
+
+export const wiltWithIndex: P.WitherableWithIndex<ImmutableArrayF>["wiltWithIndex"] = (G) => (f) => (self) =>
+  self.wiltWithIndex(G)(f);
+
+export const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"] = (G) => (f) => (self) =>
+  self.wiltWithIndex(G)((_, a) => f(a));
+
+export const witherWithIndex: P.WitherableWithIndex<ImmutableArrayF>["witherWithIndex"] = (G) => (f) => (self) =>
+  self.witherWithIndex(G)(f);
+
+export const wither: P.Witherable<ImmutableArrayF>["wither"] = (G) => (f) => (self) =>
   self.witherWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.ImmutableArray zip
+ * @tsplus pipeable fncts.ImmutableArray zip
  */
-export function zip_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<readonly [A, B]> {
-  return self.zipWith(that, tuple);
+export function zip<B>(that: ImmutableArray<B>) {
+  return <A>(self: ImmutableArray<A>): ImmutableArray<readonly [A, B]> => {
+    return self.zipWith(that, tuple);
+  };
 }
 
 /**
- * @tsplus fluent fncts.ImmutableArray zipWith
+ * @tsplus pipeable fncts.ImmutableArray zipWith
  */
-export function zipWith_<A, B, C>(
-  self: ImmutableArray<A>,
-  fb: ImmutableArray<B>,
-  f: (a: A, b: B) => C,
-): ImmutableArray<C> {
-  const len = Math.min(self.length, fb.length);
-  const fc  = Array<C>(len);
-  for (let i = 0; i < len; i++) {
-    fc[i] = f(self._array[i]!, fb._array[i]!);
-  }
-  return fc.asImmutableArray;
+export function zipWith<A, B, C>(fb: ImmutableArray<B>, f: (a: A, b: B) => C) {
+  return (self: ImmutableArray<A>): ImmutableArray<C> => {
+    const len = Math.min(self.length, fb.length);
+    const fc  = Array<C>(len);
+    for (let i = 0; i < len; i++) {
+      fc[i] = f(self._array[i]!, fb._array[i]!);
+    }
+    return fc.asImmutableArray;
+  };
 }