@fncts/base 0.0.19 → 0.0.21

package/_mjs/collection/immutable/ImmutableArray/api.mjs

@@ -13,145 +13,162 @@ import * as tsplus_module_12 from "@fncts/base/collection/immutable/ImmutableNon
 import * as tsplus_module_13 from "@fncts/base/collection/immutable/Dictionary/definition";
 import * as tsplus_module_14 from "@fncts/base/collection/immutable/Dictionary/api";
 import * as tsplus_module_15 from "@fncts/base/typeclass/Ord/instances";
-import * as tsplus_module_16 from "@fncts/base/typeclass/TraversableWithIndex";
-import * as tsplus_module_17 from "@fncts/base/data/Either/destructors";
-import * as tsplus_module_18 from "@fncts/base/typeclass/WitherableWithIndex";
-export const alignWith_ = alignWith_1;
-export const append_ = append_1;
-export const crossWith_ = crossWith_1;
-export const flatMapWithIndex_ = flatMapWithIndex_1;
-export const flatMap_ = flatMap_1;
+import * as tsplus_module_16 from "@fncts/base/data/Either/destructors";
+export const alignWith = alignWith_1;
+export const append = append_1;
+export const crossWith = crossWith_1;
+export const flatMapWithIndex = flatMapWithIndex_1;
+export const flatMap = flatMap_1;
 export const flatten = flatten_1;
-export const concat_ = concat_1;
-export const elem_ = elem_1;
-export const everyWithIndex_ = everyWithIndex_1;
-export const filter_ = filter_1;
-export const filterWithIndex_ = filterWithIndex_1;
-export const filterMapWithIndex_ = filterMapWithIndex_1;
-export const findWithIndex_ = findWithIndex_1;
-export const findMapWithIndex_ = findMapWithIndex_1;
-export const findLastMapWithIndex_ = findLastMapWithIndex_1;
-export const foldLeftWithIndex_ = foldLeftWithIndex_1;
-export const foldLeft_ = foldLeft_1;
-export const foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_1;
+export const chop = chop_1;
+export const concat = concat_1;
+export const elem = elem_1;
+export const everyWithIndex = everyWithIndex_1;
+export const filter = filter_1;
+export const filterWithIndex = filterWithIndex_1;
+export const filterMapWithIndex = filterMapWithIndex_1;
+export const findWithIndex = findWithIndex_1;
+export const findMapWithIndex = findMapWithIndex_1;
+export const findLastMapWithIndex = findLastMapWithIndex_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldLeft = foldLeft_1;
+export const foldLeftWithIndexWhile = foldLeftWithIndexWhile_1;
 export const fold = fold_1;
-export const foldMapWithIndex_ = foldMapWithIndex_1;
-export const foldRightWithIndex_ = foldRightWithIndex_1;
-export const foldRightWithIndexWhile_ = foldRightWithIndexWhile_1;
-export const forEach_ = forEach_1;
-export const get_ = get_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
+export const foldRightWithIndexWhile = foldRightWithIndexWhile_1;
+export const forEach = forEach_1;
+export const get = get_1;
 export const isEmpty = isEmpty_1;
-export const isOutOfBound_ = isOutOfBound_1;
-export const map_ = map_1;
-export const mapWithIndex_ = mapWithIndex_1;
-export const mutate_ = mutate_1;
+export const isOutOfBound = isOutOfBound_1;
+export const map = map_1;
+export const mapWithIndex = mapWithIndex_1;
+export const mutate = mutate_1;
 export const mutableClone = mutableClone_1;
-export const partitionWithIndex_ = partitionWithIndex_1;
-export const partitionMapWithIndex_ = partitionMapWithIndex_1;
-export const prepend_ = prepend_1;
-export const prependAll_ = prependAll_1;
-export const rotate_ = rotate_1;
+export const partitionWithIndex = partitionWithIndex_1;
+export const partitionMapWithIndex = partitionMapWithIndex_1;
+export const prepend = prepend_1;
+export const prependAll = prependAll_1;
+export const rotate = rotate_1;
 export const sort = sort_1;
-export const spanIndexLeft_ = spanIndexLeft_1;
-export const spanIndexRight_ = spanIndexRight_1;
+export const spanIndexLeft = spanIndexLeft_1;
+export const spanIndexRight = spanIndexRight_1;
+export const _traverseWithIndex = _traverseWithIndex_1;
+export const _traverse = _traverse_1;
 export const unsafeGet = unsafeGet_1;
 export const unsafeAsMutable = unsafeAsMutable_1;
-export const unsafeDeleteAt_ = unsafeDeleteAt_1;
-export const unsafeInsertAt_ = unsafeInsertAt_1;
-export const unsafeModifyAt_ = unsafeModifyAt_1;
-export const unsafeUpdateAt_ = unsafeUpdateAt_1;
-export const zipWith_ = zipWith_1;
-import { identity, tuple } from "@fncts/base/data/function";
+export const unsafeDeleteAt = unsafeDeleteAt_1;
+export const unsafeInsertAt = unsafeInsertAt_1;
+export const unsafeModifyAt = unsafeModifyAt_1;
+export const unsafeUpdateAt = unsafeUpdateAt_1;
+export const _wiltWithIndex = _wiltWithIndex_1;
+export const _witherWithIndex = _witherWithIndex_1;
+export const zipWith = zipWith_1;
+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
  */
 
-function alignWith_1(self, fb, f) {
-  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(maxlen);
+function alignWith_1(fb, f) {
+  return self => {
+    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(maxlen);
 
-  for (let i = 0; i < minlen; i++) {
-    ret[i] = f(tsplus_module_1.both(selfArray[i], thatArray[i]));
-  }
-
-  if (minlen === maxlen) {
-    return tsplus_module_2.asImmutableArray(ret);
-  } else if (selfArray.length > thatArray.length) {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(tsplus_module_1.left(selfArray[i]));
+    for (let i = 0; i < minlen; i++) {
+      ret[i] = f(tsplus_module_1.both(selfArray[i], thatArray[i]));
     }
-  } else {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(tsplus_module_1.right(thatArray[i]));
+
+    if (minlen === maxlen) {
+      return tsplus_module_2.asImmutableArray(ret);
+    } else if (selfArray.length > thatArray.length) {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_1.left(selfArray[i]));
+      }
+    } else {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_1.right(thatArray[i]));
+      }
     }
-  }
 
-  return tsplus_module_2.asImmutableArray(ret);
+    return tsplus_module_2.asImmutableArray(ret);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray align
+ * @tsplus pipeable fncts.ImmutableArray align
  */
 
 
-export function align_(self, fb) {
-  return alignWith_1(self, fb, identity);
+export function align(fb) {
+  return self => {
+    return alignWith_1(fb, identity)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray alt
+ * @tsplus pipeable fncts.ImmutableArray alt
  */
 
-export function alt_(self, that) {
-  return concat_1(self, that());
+export function alt(that) {
+  return self => {
+    return concat_1(that())(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray ap
+ * @tsplus pipeable fncts.ImmutableArray ap
  */
 
-export function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, f));
+export function ap(fa) {
+  return self => {
+    return flatMap_1(f => map_1(f)(fa))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray append
+ * @tsplus pipeable fncts.ImmutableArray append
  */
 
-function append_1(self, last) {
-  const selfArray = self._array;
-  const len = selfArray.length;
-  const r = Array(len + 1);
-  r[len] = last;
+function append_1(last) {
+  return self => {
+    const selfArray = self._array;
+    const len = selfArray.length;
+    const r = Array(len + 1);
+    r[len] = last;
 
-  for (let i = 0; i < len; i++) {
-    r[i] = selfArray[i];
-  }
+    for (let i = 0; i < len; i++) {
+      r[i] = selfArray[i];
+    }
 
-  return tsplus_module_2.asImmutableArray(r);
+    return tsplus_module_2.asImmutableArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray crossWith
+ * @tsplus pipeable fncts.ImmutableArray crossWith
  */
 
 
-function crossWith_1(self, fb, f) {
-  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+function crossWith_1(fb, f) {
+  return self => {
+    return flatMap_1(a => map_1(b => f(a, b))(fb))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray cross
+ * @tsplus pipeable fncts.ImmutableArray cross
  */
 
 
-export function cross_(self, fb) {
-  return crossWith_1(self, fb, (a, b) => tsplus_module_3.make(a, b));
+export function cross(fb) {
+  return self => {
+    return crossWith_1(fb, (a, b) => tsplus_module_3.make(a, b))(self);
+  };
 }
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  */
 
 export function chainRecDepthFirst(a, f) {
-  const buffer = unsafeAsMutable_1(tsplus_module_4.slice_(f(a)));
+  const buffer = unsafeAsMutable_1(tsplus_module_4.slice()(f(a)));
   const out = [];
 
   while (buffer.length > 0) {
@@ -182,7 +199,7 @@ export function chainRecBreadthFirst(a, f) {
     void 0;
 
     if (e._tag === "Left") {
-      forEach_1(f(e.left), v => buffer.push(v));
+      forEach_1(v => buffer.push(v))(f(e.left));
     } else {
       out.push(e.right);
     }
@@ -199,47 +216,51 @@ export function chainRecBreadthFirst(a, f) {
   return tsplus_module_2.asImmutableArray(out);
 }
 /**
- * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray flatMapWithIndex
  */
 
-function flatMapWithIndex_1(self, f) {
-  let outLen = 0;
-  const selfArray = self._array;
-  const len = selfArray.length;
-  const temp = Array(len);
+function flatMapWithIndex_1(f) {
+  return self => {
+    let outLen = 0;
+    const selfArray = self._array;
+    const len = selfArray.length;
+    const temp = Array(len);
 
-  for (let i = 0; i < len; i++) {
-    const e = selfArray[i];
+    for (let i = 0; i < len; i++) {
+      const e = selfArray[i];
 
-    const arr = f(i, e)._array;
+      const arr = f(i, e)._array;
 
-    outLen += arr.length;
-    temp[i] = arr;
-  }
+      outLen += arr.length;
+      temp[i] = arr;
+    }
 
-  const out = Array(outLen);
-  let start = 0;
+    const out = Array(outLen);
+    let start = 0;
 
-  for (let i = 0; i < len; i++) {
-    const arr = temp[i];
-    const l = arr.length;
+    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];
-    }
+      for (let j = 0; j < l; j++) {
+        out[j + start] = arr[j];
+      }
 
-    start += l;
-  }
+      start += l;
+    }
 
-  return tsplus_module_2.asImmutableArray(out);
+    return tsplus_module_2.asImmutableArray(out);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray flatMap
+ * @tsplus pipeable fncts.ImmutableArray flatMap
  */
 
 
-function flatMap_1(self, f) {
-  return flatMapWithIndex_1(self, (_, a) => f(a));
+function flatMap_1(f) {
+  return self => {
+    return flatMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray flatten
@@ -247,55 +268,59 @@ function flatMap_1(self, f) {
 
 
 function flatten_1(self) {
-  return flatMap_1(self, identity);
+  return flatMap_1(identity)(self);
 }
 /**
  * A useful recursion pattern for processing a `Array` to produce a new `Array`,
  * 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
+ * @tsplus pipeable fncts.ImmutableArray chop
  */
 
 
-export function chop_(as, f) {
-  const result = [];
-  let cs = as;
+function chop_1(f) {
+  return as => {
+    const result = [];
+    let cs = as;
 
-  while (tsplus_module_5.isNonEmpty(cs)) {
-    const [b, c] = f(cs);
-    result.push(b);
-    cs = c;
-  }
+    while (tsplus_module_5.isNonEmpty(cs)) {
+      const [b, c] = f(cs);
+      result.push(b);
+      cs = c;
+    }
 
-  return tsplus_module_2.asImmutableArray(result);
+    return tsplus_module_2.asImmutableArray(result);
+  };
 }
-export const chop = f => as => chop_(as, f);
 /**
- * @tsplus fluent fncts.ImmutableArray collectWhile
+ * @tsplus pipeable fncts.ImmutableArray collectWhile
  */
 
-export function collectWhile_(as, f) {
-  const result = [];
 
-  for (let i = 0; i < tsplus_module_5.length(as); i++) {
-    const o = f(as._array[i]);
+export function collectWhile(f) {
+  return as => {
+    const result = [];
 
-    if (tsplus_module_6.isJust(o)) {
-      result.push(o.value);
-    } else {
-      break;
+    for (let i = 0; i < tsplus_module_5.length(as); i++) {
+      const o = f(as._array[i]);
+
+      if (tsplus_module_6.isJust(o)) {
+        result.push(o.value);
+      } else {
+        break;
+      }
     }
-  }
 
-  return tsplus_module_2.asImmutableArray(result);
+    return tsplus_module_2.asImmutableArray(result);
+  };
 }
 
 function comprehensionLoop(scope, input, f, g) {
   if (input.length === 0) {
     return g(...scope) ? tsplus_module_7.now(tsplus_module_2.make(f(...scope))) : tsplus_module_7.now(tsplus_module_2.empty());
   } else {
-    return tsplus_module_9.map_(traverse_1(input[0])(tsplus_module_8.Applicative)(a => comprehensionLoop(append_1(scope, a), input.slice(1), f, g)), rs => flatten_1(rs));
+    return tsplus_module_9.map(rs => flatten_1(rs))(_traverse_1(input[0])(tsplus_module_8.Applicative)(a => comprehensionLoop(append_1(a)(scope), input.slice(1), f, g)));
   }
 }
 
@@ -303,412 +328,490 @@ export function comprehension(input, f, g = () => true) {
   return tsplus_module_10.run(comprehensionLoop(tsplus_module_2.empty(), input, f, g));
 }
 /**
- * @tsplus fluent fncts.ImmutableArray concat
- * @tsplus operator fncts.ImmutableArray +
+ * @tsplus pipeable fncts.ImmutableArray concat
+ * @tsplus pipeable-operator fncts.ImmutableArray +
  */
 
-function concat_1(self, that) {
-  const lenx = self._array.length;
+function concat_1(that) {
+  return self => {
+    const lenx = self._array.length;
 
-  if (lenx === 0) {
-    return that;
-  }
+    if (lenx === 0) {
+      return that;
+    }
 
-  const leny = that._array.length;
+    const leny = that._array.length;
 
-  if (leny === 0) {
-    return self;
-  }
+    if (leny === 0) {
+      return self;
+    }
 
-  const r = Array(lenx + leny);
+    const r = Array(lenx + leny);
 
-  for (let i = 0; i < lenx; i++) {
-    r[i] = self._array[i];
-  }
+    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];
-  }
+    for (let i = 0; i < leny; i++) {
+      r[i + lenx] = that._array[i];
+    }
 
-  return tsplus_module_2.asImmutableArray(r);
+    return tsplus_module_2.asImmutableArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray deleteAt
+ * @tsplus pipeable fncts.ImmutableArray deleteAt
  */
 
 
-export function deleteAt_(as, i) {
-  return isOutOfBound_1(as, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeDeleteAt_1(as, i));
+export function deleteAt(i) {
+  return as => {
+    return isOutOfBound_1(i)(as) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeDeleteAt_1(i)(as));
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray difference
+ * @tsplus pipeable fncts.ImmutableArray difference
  */
 
-export function difference_(self, ys,
+export function difference(ys,
 /** @tsplus auto */
 E) {
-  return filter_1(self, a => !elem_1(ys, a, E));
+  return self => {
+    return filter_1(a => !elem_1(a, E)(ys))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray drop
+ * @tsplus pipeable fncts.ImmutableArray drop
  */
 
-export function drop_(self, n) {
-  return tsplus_module_4.slice_(self, n);
+export function drop(n) {
+  return self => {
+    return tsplus_module_4.slice(n)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray dropLast
+ * @tsplus pipeable fncts.ImmutableArray dropLast
  */
 
-export function dropLast_(self, n) {
-  return tsplus_module_4.slice_(self, 0, tsplus_module_5.length(self) - n);
+export function dropLast(n) {
+  return self => {
+    return tsplus_module_4.slice(0, tsplus_module_5.length(self) - n)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray dropWhile
+ * @tsplus pipeable fncts.ImmutableArray dropWhile
  */
 
-export function dropWhile_(self, p) {
-  return tsplus_module_4.slice_(self, spanIndexLeft_1(self, p));
+export function dropWhile(p) {
+  return self => {
+    return tsplus_module_4.slice(spanIndexLeft_1(p)(self))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ * @tsplus pipeable fncts.ImmutableArray dropLastWhile
  */
 
-export function dropLastWhile_(as, p) {
-  return tsplus_module_4.slice_(as, 0, spanIndexRight_1(as, p) + 1);
+export function dropLastWhile(p) {
+  return as => {
+    return tsplus_module_4.slice(0, spanIndexRight_1(p)(as) + 1)(as);
+  };
 }
 /**
  * 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 fluent fncts.ImmutableArray elem
+ * @tsplus pipeable fncts.ImmutableArray elem
  */
 
-function elem_1(as, a,
+function elem_1(a,
 /** @tsplus auto */
 E) {
-  const predicate = element => E.equals(element, a);
+  return as => {
+    const predicate = element => E.equals(element, a);
 
-  const len = tsplus_module_5.length(as);
+    const len = tsplus_module_5.length(as);
 
-  for (let i = 0; i < len; i++) {
-    if (predicate(as._array[i])) {
-      return true;
+    for (let i = 0; i < len; i++) {
+      if (predicate(as._array[i])) {
+        return true;
+      }
     }
-  }
 
-  return false;
+    return false;
+  };
 }
 
-export function every_(self, p) {
-  return everyWithIndex_1(self, (_, a) => p(a));
+export function every(p) {
+  return self => {
+    return everyWithIndex_1((_, a) => p(a))(self);
+  };
 }
 
-function everyWithIndex_1(self, p) {
-  let result = true;
-  let i = 0;
+function everyWithIndex_1(p) {
+  return self => {
+    let result = true;
+    let i = 0;
 
-  while (result && i < tsplus_module_5.length(self)) {
-    result = p(i, self._array[i]);
-    i++;
-  }
+    while (result && i < tsplus_module_5.length(self)) {
+      result = p(i, self._array[i]);
+      i++;
+    }
 
-  return result;
+    return result;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray exists
+ * @tsplus pipeable fncts.ImmutableArray exists
  */
 
 
-export function exists_(self, p) {
-  let result = false;
-  let i = 0;
+export function exists(p) {
+  return self => {
+    let result = false;
+    let i = 0;
 
-  while (!result && i < tsplus_module_5.length(self)) {
-    result = p(self._array[i]);
-    i++;
-  }
+    while (!result && i < tsplus_module_5.length(self)) {
+      result = p(self._array[i]);
+      i++;
+    }
 
-  return result;
+    return result;
+  };
 }
 
-function filter_1(self, p) {
-  return filterWithIndex_1(self, (_, a) => p(a));
+function filter_1(p) {
+  return self => {
+    return filterWithIndex_1((_, a) => p(a))(self);
+  };
 }
 
-function filterWithIndex_1(self, p) {
-  const result = [];
+function filterWithIndex_1(p) {
+  return self => {
+    const result = [];
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    const a = self._array[i];
+    for (let i = 0; i < tsplus_module_5.length(self); i++) {
+      const a = self._array[i];
 
-    if (p(i, a)) {
-      result.push(a);
+      if (p(i, a)) {
+        result.push(a);
+      }
     }
-  }
 
-  return tsplus_module_2.asImmutableArray(result);
+    return tsplus_module_2.asImmutableArray(result);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray filterMapWithIndex
  */
 
 
-function filterMapWithIndex_1(fa, f) {
-  const result = [];
+function filterMapWithIndex_1(f) {
+  return fa => {
+    const result = [];
 
-  for (let i = 0; i < tsplus_module_5.length(fa); i++) {
-    const maybeB = f(i, unsafeGet_1(fa, i));
+    for (let i = 0; i < tsplus_module_5.length(fa); i++) {
+      const maybeB = f(i, unsafeGet_1(fa, i));
 
-    if (tsplus_module_6.isJust(maybeB)) {
-      result.push(maybeB.value);
+      if (tsplus_module_6.isJust(maybeB)) {
+        result.push(maybeB.value);
+      }
     }
-  }
 
-  return tsplus_module_2.asImmutableArray(result);
+    return tsplus_module_2.asImmutableArray(result);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray filterMap
+ * @tsplus pipeable fncts.ImmutableArray filterMap
  */
 
 
-export function filterMap_(self, f) {
-  return filterMapWithIndex_1(self, (_, a) => f(a));
+export function filterMap(f) {
+  return self => {
+    return filterMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
-export function find_(self, p) {
-  return findWithIndex_1(self, (_, a) => p(a));
+export function find(p) {
+  return self => {
+    return findWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findIndex
+ * @tsplus pipeable fncts.ImmutableArray findIndex
  */
 
-export function findIndex_(as, predicate) {
-  return findMapWithIndex_1(as, (i, a) => predicate(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing());
+export function findIndex(predicate) {
+  return as => {
+    return findMapWithIndex_1((i, a) => predicate(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing())(as);
+  };
 }
 
-function findWithIndex_1(as, p) {
-  const len = tsplus_module_5.length(as);
+function findWithIndex_1(p) {
+  return as => {
+    const len = tsplus_module_5.length(as);
 
-  for (let i = 0; i < len; i++) {
-    if (p(i, as._array[i])) {
-      return tsplus_module_11.just(as._array[i]);
+    for (let i = 0; i < len; i++) {
+      if (p(i, as._array[i])) {
+        return tsplus_module_11.just(as._array[i]);
+      }
     }
-  }
 
-  return tsplus_module_11.nothing();
+    return tsplus_module_11.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findMap
+ * @tsplus pipeable fncts.ImmutableArray findMap
  */
 
 
-export function findMap_(as, f) {
-  return findMapWithIndex_1(as, (_, a) => f(a));
+export function findMap(f) {
+  return as => {
+    return findMapWithIndex_1((_, a) => f(a))(as);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findMapWithIndex
  */
 
-function findMapWithIndex_1(as, f) {
-  const len = tsplus_module_5.length(as);
+function findMapWithIndex_1(f) {
+  return as => {
+    const len = tsplus_module_5.length(as);
 
-  for (let i = 0; i < len; i++) {
-    const v = f(i, as._array[i]);
+    for (let i = 0; i < len; i++) {
+      const v = f(i, as._array[i]);
 
-    if (tsplus_module_6.isJust(v)) {
-      return v;
+      if (tsplus_module_6.isJust(v)) {
+        return v;
+      }
     }
-  }
 
-  return tsplus_module_11.nothing();
+    return tsplus_module_11.nothing();
+  };
 }
 
-export function findLast_(as, p) {
-  const len = tsplus_module_5.length(as);
+export function findLast(p) {
+  return as => {
+    const len = tsplus_module_5.length(as);
 
-  for (let i = len - 1; i >= 0; i--) {
-    if (p(as._array[i])) {
-      return tsplus_module_11.just(as._array[i]);
+    for (let i = len - 1; i >= 0; i--) {
+      if (p(as._array[i])) {
+        return tsplus_module_11.just(as._array[i]);
+      }
     }
-  }
 
-  return tsplus_module_11.nothing();
+    return tsplus_module_11.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findLastIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastIndex
  */
 
-export function findLastIndex_(self, p) {
-  return findLastMapWithIndex_1(self, (i, a) => p(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing());
+export function findLastIndex(p) {
+  return self => {
+    return findLastMapWithIndex_1((i, a) => p(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing())(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMap
+ * @tsplus pipeable fncts.ImmutableArray findLastMap
  */
 
-export function findLastMap_(as, f) {
-  return findLastMapWithIndex_1(as, (_, a) => f(a));
+export function findLastMap(f) {
+  return as => {
+    return findLastMapWithIndex_1((_, a) => f(a))(as);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastMapWithIndex
  */
 
-function findLastMapWithIndex_1(as, f) {
-  const len = tsplus_module_5.length(as);
+function findLastMapWithIndex_1(f) {
+  return as => {
+    const len = tsplus_module_5.length(as);
 
-  for (let i = len - 1; i >= 0; i--) {
-    const v = f(i, as._array[i]);
+    for (let i = len - 1; i >= 0; i--) {
+      const v = f(i, as._array[i]);
 
-    if (tsplus_module_6.isJust(v)) {
-      return v;
+      if (tsplus_module_6.isJust(v)) {
+        return v;
+      }
     }
-  }
 
-  return tsplus_module_11.nothing();
+    return tsplus_module_11.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.MutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndex
  */
 
 
-function foldLeftWithIndex_1(self, b, f) {
-  const len = tsplus_module_5.length(self);
-  let r = b;
+function foldLeftWithIndex_1(b, f) {
+  return self => {
+    const len = tsplus_module_5.length(self);
+    let r = b;
 
-  for (let i = 0; i < len; i++) {
-    r = f(i, r, self._array[i]);
-  }
+    for (let i = 0; i < len; i++) {
+      r = f(i, r, self._array[i]);
+    }
 
-  return r;
+    return r;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.MutableArray foldLeft
+ * @tsplus pipeable fncts.ImmutableArray foldLeft
+ * @tsplus pipeable fncts.MutableArray foldLeft
  */
 
 
-function foldLeft_1(self, b, f) {
-  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+function foldLeft_1(b, f) {
+  return self => {
+    return foldLeftWithIndex_1(b, (_, b, a) => f(b, a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.MutableArray foldLeftWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWhile
  */
 
 
-export function foldLeftWhile_(self, b, p, f) {
-  return foldLeftWithIndexWhile_1(self, b, p, (_, b, a) => f(b, a));
+export function foldLeftWhile(b, p, f) {
+  return self => {
+    return foldLeftWithIndexWhile_1(b, p, (_, b, a) => f(b, a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndexWhile
  */
 
-function foldLeftWithIndexWhile_1(self, b, p, f) {
-  let out = b;
-  let cont = p(out);
+function foldLeftWithIndexWhile_1(b, p, f) {
+  return self => {
+    let out = b;
+    let cont = p(out);
 
-  for (let i = 0; cont && i < tsplus_module_5.length(self); i++) {
-    out = f(i, out, self._array[i]);
-    cont = p(out);
-  }
+    for (let i = 0; cont && i < tsplus_module_5.length(self); i++) {
+      out = f(i, out, self._array[i]);
+      cont = p(out);
+    }
 
-  return out;
+    return out;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus pipeable fncts.ImmutableArray fold
  */
 
 
-function fold_1(self,
+function fold_1(
 /** @tsplus auto */
 M) {
-  return foldLeft_1(self, M.nat, M.combine);
+  return self => {
+    return foldLeft_1(M.nat, M.combine)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldMapWithIndex
  */
 
 
-function foldMapWithIndex_1(self, f,
+function foldMapWithIndex_1(f,
 /** @tsplus auto */
 M) {
-  return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+  return self => {
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(b, f(i, a)))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldMap
+ * @tsplus pipeable fncts.ImmutableArray foldMap
  */
 
 
-export function foldMap_(self, f,
+export function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndex
  */
 
-function foldRightWithIndex_1(self, b, f) {
-  let r = b;
+function foldRightWithIndex_1(b, f) {
+  return self => {
+    let r = b;
 
-  for (let i = tsplus_module_5.length(self) - 1; i >= 0; i--) {
-    r = f(i, self._array[i], r);
-  }
+    for (let i = tsplus_module_5.length(self) - 1; i >= 0; i--) {
+      r = f(i, self._array[i], r);
+    }
 
-  return r;
+    return r;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus pipeable fncts.ImmutableArray foldRight
  */
 
 
-export function foldRight_(self, b, f) {
-  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+export function foldRight(b, f) {
+  return self => {
+    return foldRightWithIndex_1(b, (_, a, b) => f(a, b))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRighWhile
  */
 
-export function foldRightWhile_(self, b, p, f) {
-  return foldRightWithIndexWhile_1(self, b, p, (_, a, b) => f(a, b));
+export function foldRightWhile(b, p, f) {
+  return self => {
+    return foldRightWithIndexWhile_1(b, p, (_, a, b) => f(a, b))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndexWhile
  */
 
-function foldRightWithIndexWhile_1(self, b, predicate, f) {
-  let out = b;
-  let cont = predicate(out);
+function foldRightWithIndexWhile_1(b, predicate, f) {
+  return self => {
+    let out = b;
+    let cont = predicate(out);
 
-  for (let i = tsplus_module_5.length(self) - 1; cont && i >= 0; i--) {
-    out = f(i, self._array[i], out);
-    cont = predicate(out);
-  }
+    for (let i = tsplus_module_5.length(self) - 1; cont && i >= 0; i--) {
+      out = f(i, self._array[i], out);
+      cont = predicate(out);
+    }
 
-  return out;
+    return out;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray forEach
+ * @tsplus pipeable fncts.ImmutableArray forEach
  */
 
 
-function forEach_1(self, f) {
-  return forEach_1(self, f);
+function forEach_1(f) {
+  return self => {
+    return forEach_1(f)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.MutableArray get
+ * @tsplus pipeable fncts.ImmutableArray get
+ * @tsplus pipeable fncts.MutableArray get
  */
 
 
-function get_1(self, i) {
-  return isOutOfBound_1(self, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(self._array[i]);
+function get_1(i) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_11.nothing() : tsplus_module_11.just(self._array[i]);
+  };
 }
+/**
+ * @tsplus pipeable fncts.ImmutableArray group
+ */
+
 
 export function group(E) {
-  return chop(self => {
+  return chop_1(self => {
     const h = self._array[0];
     const out = [h];
     let i = 1;
@@ -723,35 +826,30 @@ export function group(E) {
       }
     }
 
-    return [tsplus_module_12.unsafeAsNonEmptyArray(out), tsplus_module_4.slice_(self, i)];
+    return [tsplus_module_12.unsafeAsNonEmptyArray(out), tsplus_module_4.slice(i)(self)];
   });
 }
 /**
- * @tsplus fluent fncts.ImmutableArray group
+ * @tsplus pipeable fncts.ImmutableArray groupBy
  */
 
-export function chopSelf(self, E) {
-  return group(E)(self);
-}
-/**
- * @tsplus fluent fncts.ImmutableArray groupBy
- */
-
-export function groupBy_(self, f) {
-  const out = {};
+export function groupBy(f) {
+  return self => {
+    const out = {};
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    const a = self._array[i];
-    const k = f(a);
+    for (let i = 0; i < tsplus_module_5.length(self); 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];
+      if (Object.prototype.hasOwnProperty.call(out, k)) {
+        out[k].push(a);
+      } else {
+        out[k] = [a];
+      }
     }
-  }
 
-  return tsplus_module_14.map_(tsplus_module_13.Dictionary.get(out), tsplus_module_12.from);
+    return tsplus_module_14.map(tsplus_module_12.from)(tsplus_module_13.Dictionary.get(out));
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray head
@@ -766,27 +864,37 @@ export function head(self) {
 
 export function init(self) {
   const len = tsplus_module_5.length(self);
-  return len === 0 ? tsplus_module_11.nothing() : tsplus_module_11.just(tsplus_module_4.slice_(self, 0, len - 1));
+  return len === 0 ? tsplus_module_11.nothing() : tsplus_module_11.just(tsplus_module_4.slice(0, len - 1)(self));
 }
 /**
- * @tsplus fluent fncts.ImmutableArray insertAt
+ * @tsplus pipeable fncts.ImmutableArray insertAt
  */
 
-export function insertAt_(self, i, a) {
-  return isOutOfBound_1(self, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeInsertAt_1(self, i, a));
+export function insertAt(i, a) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeInsertAt_1(i, a)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray intersection
+ * @tsplus pipeable fncts.ImmutableArray intersection
  */
 
-export function intersection_(self, that,
+export function intersection(that,
 /** @tsplus auto */
 E) {
-  return filter_1(self, a => elem_1(that, a, E));
+  return self => {
+    return filter_1(a => elem_1(a, E)(that))(self);
+  };
 }
-export function intersperse_(self, a) {
-  const len = tsplus_module_5.length(self);
-  return len === 0 ? self : prepend_1(prependAll_1(tsplus_module_4.slice_(self, 1, len), a), unsafeGet_1(self, 0));
+/**
+ * @tsplus pipeable fncts.ImmutableArray intersperse
+ */
+
+export function intersperse(a) {
+  return self => {
+    const len = tsplus_module_5.length(self);
+    return len === 0 ? self : prepend_1(unsafeGet_1(self, 0))(prependAll_1(a)(tsplus_module_4.slice(1, len)(self)));
+  };
 }
 /**
  * @tsplus fluent fncts.ImmutableArray isEmpty
@@ -796,27 +904,31 @@ function isEmpty_1(self) {
   return tsplus_module_5.length(self) === 0;
 }
 /**
- * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ * @tsplus pipeable fncts.ImmutableArray isOutOfBound
  */
 
 
-function isOutOfBound_1(self, i) {
-  return i < 0 || i >= tsplus_module_5.length(self);
+function isOutOfBound_1(i) {
+  return self => {
+    return i < 0 || i >= tsplus_module_5.length(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray join
+ * @tsplus pipeable fncts.ImmutableArray join
  */
 
 
-export function join(self, separator) {
-  return self._array.join(separator);
+export function join(separator) {
+  return self => {
+    return self._array.join(separator);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray last
  */
 
 export function last(self) {
-  return get_1(self, tsplus_module_5.length(self) - 1);
+  return get_1(tsplus_module_5.length(self) - 1)(self);
 }
 /**
  * @tsplus getter fncts.ImmutableArray length
@@ -846,59 +958,69 @@ export function lefts(self) {
   return tsplus_module_2.asImmutableArray(ls);
 }
 /**
- * @tsplus fluent fncts.ImmutableArray map
+ * @tsplus pipeable fncts.ImmutableArray map
  */
 
-function map_1(self, f) {
-  return mapWithIndex_1(self, (_, a) => f(a));
+function map_1(f) {
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray mapAccum
+ * @tsplus pipeable fncts.ImmutableArray mapAccum
  */
 
 
-export function mapAccum_(self, s, f) {
-  const bs = Array(tsplus_module_5.length(self));
-  let state = s;
+export function mapAccum(s, f) {
+  return self => {
+    const bs = Array(tsplus_module_5.length(self));
+    let state = s;
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    const result = f(state, self._array[i]);
-    bs[i] = result[0];
-    state = result[1];
-  }
+    for (let i = 0; i < tsplus_module_5.length(self); i++) {
+      const result = f(state, self._array[i]);
+      bs[i] = result[0];
+      state = result[1];
+    }
 
-  return [tsplus_module_2.asImmutableArray(bs), state];
+    return [tsplus_module_2.asImmutableArray(bs), state];
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray mapWithIndex
  */
 
-function mapWithIndex_1(self, f) {
-  const len = self._array.length;
-  const bs = Array(len);
+function mapWithIndex_1(f) {
+  return self => {
+    const len = self._array.length;
+    const bs = Array(len);
 
-  for (let i = 0; i < len; i++) {
-    bs[i] = f(i, self._array[i]);
-  }
+    for (let i = 0; i < len; i++) {
+      bs[i] = f(i, self._array[i]);
+    }
 
-  return tsplus_module_2.asImmutableArray(bs);
+    return tsplus_module_2.asImmutableArray(bs);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray modifyAt
+ * @tsplus pipeable fncts.ImmutableArray modifyAt
  */
 
 
-export function modifyAt_(self, i, f) {
-  return isOutOfBound_1(self, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeModifyAt_1(self, i, f));
+export function modifyAt(i, f) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeModifyAt_1(i, f)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray mutate
+ * @tsplus pipeable fncts.ImmutableArray mutate
  */
 
-function mutate_1(self, f) {
-  const mut = mutableClone_1(self);
-  f(mut);
-  return tsplus_module_2.asImmutableArray(mut);
+function mutate_1(f) {
+  return self => {
+    const mut = mutableClone_1(self);
+    f(mut);
+    return tsplus_module_2.asImmutableArray(mut);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray mutableClone
@@ -906,95 +1028,106 @@ function mutate_1(self, f) {
 
 
 function mutableClone_1(self) {
-  return tsplus_module_4.slice_(self, 0)._array;
+  return tsplus_module_4.slice(0)(self)._array;
 }
 
-function partitionWithIndex_1(self, p) {
-  const left = [];
-  const right = [];
+function partitionWithIndex_1(p) {
+  return self => {
+    const left = [];
+    const right = [];
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    const a = self._array[i];
+    for (let i = 0; i < tsplus_module_5.length(self); i++) {
+      const a = self._array[i];
 
-    if (p(i, a)) {
-      right.push(a);
-    } else {
-      left.push(a);
+      if (p(i, a)) {
+        right.push(a);
+      } else {
+        left.push(a);
+      }
     }
-  }
 
-  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+    return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+  };
 }
 
-export function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+export function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray partitionMapWithIndex
  */
 
-function partitionMapWithIndex_1(self, f) {
-  const left = [];
-  const right = [];
+function partitionMapWithIndex_1(f) {
+  return self => {
+    const left = [];
+    const right = [];
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    const ea = f(i, self._array[i]);
-    void 0;
+    for (let i = 0; i < tsplus_module_5.length(self); i++) {
+      const ea = f(i, self._array[i]);
+      void 0;
 
-    switch (ea._tag) {
-      case "Left"
-      /* EitherTag.Left */
-      :
-        left.push(ea.left);
-        break;
+      switch (ea._tag) {
+        case "Left"
+        /* EitherTag.Left */
+        :
+          left.push(ea.left);
+          break;
 
-      case "Right"
-      /* EitherTag.Right */
-      :
-        right.push(ea.right);
-        break;
+        case "Right"
+        /* EitherTag.Right */
+        :
+          right.push(ea.right);
+          break;
+      }
     }
-  }
 
-  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+    return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray partitionMap
+ * @tsplus pipeable fncts.ImmutableArray partitionMap
  */
 
 
-export function partitionMap_(self, f) {
-  return partitionMapWithIndex_1(self, (_, a) => f(a));
+export function partitionMap(f) {
+  return self => {
+    return partitionMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray prepend
+ * @tsplus pipeable fncts.ImmutableArray prepend
  */
 
-function prepend_1(self, head) {
-  const len = tsplus_module_5.length(self);
-  const out = Array(len + 1);
-  out[0] = head;
+function prepend_1(head) {
+  return self => {
+    const len = tsplus_module_5.length(self);
+    const out = Array(len + 1);
+    out[0] = head;
 
-  for (let i = 0; i < len; i++) {
-    out[i + 1] = self._array[i];
-  }
+    for (let i = 0; i < len; i++) {
+      out[i + 1] = self._array[i];
+    }
 
-  return tsplus_module_2.asImmutableArray(out);
+    return tsplus_module_2.asImmutableArray(out);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.MutableArray prependAll
+ * @tsplus pipeable fncts.ImmutableArray prependAll
  */
 
 
-function prependAll_1(self, a) {
-  const out = [];
+function prependAll_1(a) {
+  return self => {
+    const out = [];
 
-  for (let i = 0; i < tsplus_module_5.length(self); i++) {
-    out.push(a, self._array[i]);
-  }
+    for (let i = 0; i < tsplus_module_5.length(self); i++) {
+      out.push(a, self._array[i]);
+    }
 
-  return tsplus_module_2.asImmutableArray(out);
+    return tsplus_module_2.asImmutableArray(out);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray reverse
@@ -1037,133 +1170,151 @@ export function rights(self) {
   return tsplus_module_2.asImmutableArray(rs);
 }
 /**
- * @tsplus fluent fncts.ImmutableArray rotate
+ * @tsplus pipeable fncts.ImmutableArray rotate
  */
 
-function rotate_1(self, n) {
-  const len = tsplus_module_5.length(self);
+function rotate_1(n) {
+  return self => {
+    const len = tsplus_module_5.length(self);
 
-  if (n === 0 || len <= 1 || len === Math.abs(n)) {
-    return self;
-  } else if (n < 0) {
-    return rotate_1(self, len + n);
-  } else {
-    return concat_1(tsplus_module_4.slice_(self, -n), tsplus_module_4.slice_(self, 0, len - n));
-  }
+    if (n === 0 || len <= 1 || len === Math.abs(n)) {
+      return self;
+    } else if (n < 0) {
+      return rotate_1(len + n)(self);
+    } else {
+      return concat_1(tsplus_module_4.slice(0, len - n)(self))(tsplus_module_4.slice(-n)(self));
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray scanLeft
+ * @tsplus pipeable fncts.ImmutableArray scanLeft
  */
 
 
-export function scanLeft_(self, b, f) {
-  const l = tsplus_module_5.length(self);
-  const r = Array(l + 1);
-  r[0] = b;
+export function scanLeft(b, f) {
+  return self => {
+    const l = tsplus_module_5.length(self);
+    const r = Array(l + 1);
+    r[0] = b;
 
-  for (let i = 0; i < l; i++) {
-    r[i + 1] = f(r[i], self._array[i]);
-  }
+    for (let i = 0; i < l; i++) {
+      r[i + 1] = f(r[i], self._array[i]);
+    }
 
-  return tsplus_module_2.asImmutableArray(r);
+    return tsplus_module_2.asImmutableArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray scanRight
+ * @tsplus pipeable fncts.ImmutableArray scanRight
  */
 
-export function scanRight_(self, b, f) {
-  const l = tsplus_module_5.length(self);
-  const r = Array(l + 1);
-  r[l] = b;
+export function scanRight(b, f) {
+  return self => {
+    const l = tsplus_module_5.length(self);
+    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]);
-  }
+    for (let i = l - 1; i >= 0; i--) {
+      r[i] = f(self._array[i], r[i + 1]);
+    }
 
-  return tsplus_module_2.asImmutableArray(r);
+    return tsplus_module_2.asImmutableArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray sort
+ * @tsplus pipeable fncts.ImmutableArray sort
  */
 
-function sort_1(self,
+function sort_1(
 /** @tsplus auto */
 O) {
-  return isEmpty_1(self) || tsplus_module_5.length(self) === 1 ? self : tsplus_module_2.asImmutableArray(self._array.slice().sort(O.compare));
+  return self => {
+    return isEmpty_1(self) || tsplus_module_5.length(self) === 1 ? self : tsplus_module_2.asImmutableArray(self._array.slice().sort(O.compare));
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray sortBy
+ * @tsplus pipeable fncts.ImmutableArray sortBy
  */
 
 
-export function sortBy(self, Os) {
-  return sort_1(self, fold_1(Os, tsplus_module_15.getMonoid()));
+export function sortBy(Os) {
+  return self => {
+    return sort_1(fold_1(tsplus_module_15.getMonoid())(Os))(self);
+  };
 }
-export function spanLeft_(self, p) {
-  const i = spanIndexLeft_1(self, p);
-  const init = Array(i);
+export function spanLeft(p) {
+  return self => {
+    const i = spanIndexLeft_1(p)(self);
+    const init = Array(i);
 
-  for (let j = 0; j < i; j++) {
-    init[j] = self._array[j];
-  }
+    for (let j = 0; j < i; j++) {
+      init[j] = self._array[j];
+    }
 
-  const l = tsplus_module_5.length(self);
-  const rest = Array(l - i);
+    const l = tsplus_module_5.length(self);
+    const rest = Array(l - i);
 
-  for (let j = i; j < l; j++) {
-    rest[j - i] = self._array[j];
-  }
+    for (let j = i; j < l; j++) {
+      rest[j - i] = self._array[j];
+    }
 
-  return [tsplus_module_2.asImmutableArray(init), tsplus_module_2.asImmutableArray(rest)];
+    return [tsplus_module_2.asImmutableArray(init), tsplus_module_2.asImmutableArray(rest)];
+  };
 }
-export function spanRight_(self, p) {
-  const i = spanIndexRight_1(self, p);
-  const l = tsplus_module_5.length(self);
-  const tail = Array(l - i - 1);
+export function spanRight(p) {
+  return self => {
+    const i = spanIndexRight_1(p)(self);
+    const l = tsplus_module_5.length(self);
+    const tail = Array(l - i - 1);
 
-  for (let j = l - 1; j > i; j--) {
-    tail[j - i - 1] = self._array[j];
-  }
+    for (let j = l - 1; j > i; j--) {
+      tail[j - i - 1] = self._array[j];
+    }
 
-  const rest = Array(i);
+    const rest = Array(i);
 
-  for (let j = i; j >= 0; j--) {
-    rest[j] = self._array[j];
-  }
+    for (let j = i; j >= 0; j--) {
+      rest[j] = self._array[j];
+    }
 
-  return [tsplus_module_2.asImmutableArray(rest), tsplus_module_2.asImmutableArray(tail)];
+    return [tsplus_module_2.asImmutableArray(rest), tsplus_module_2.asImmutableArray(tail)];
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ * @tsplus pipeable fncts.ImmutableArray spanIndexLeft
  */
 
-function spanIndexLeft_1(self, p) {
-  const l = tsplus_module_5.length(self);
-  let i = 0;
+function spanIndexLeft_1(p) {
+  return self => {
+    const l = tsplus_module_5.length(self);
+    let i = 0;
 
-  for (; i < l; i++) {
-    if (!p(self._array[i])) {
-      break;
+    for (; i < l; i++) {
+      if (!p(self._array[i])) {
+        break;
+      }
     }
-  }
 
-  return i;
+    return i;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ * @tsplus pipeable fncts.ImmutableArray spanIndexRight
  */
 
 
-function spanIndexRight_1(as, predicate) {
-  let i = tsplus_module_5.length(as) - 1;
+function spanIndexRight_1(predicate) {
+  return as => {
+    let i = tsplus_module_5.length(as) - 1;
 
-  for (; i >= 0; i--) {
-    if (!predicate(as._array[i])) {
-      break;
+    for (; i >= 0; i--) {
+      if (!predicate(as._array[i])) {
+        break;
+      }
     }
-  }
 
-  return i;
+    return i;
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray tail
@@ -1171,84 +1322,96 @@ function spanIndexRight_1(as, predicate) {
 
 
 export function tail(self) {
-  return tsplus_module_5.isNonEmpty(self) ? tsplus_module_11.just(tsplus_module_4.slice_(self, 1)) : tsplus_module_11.nothing();
+  return tsplus_module_5.isNonEmpty(self) ? tsplus_module_11.just(tsplus_module_4.slice(1)(self)) : tsplus_module_11.nothing();
 }
 /**
- * @tsplus fluent fncts.ImmutableArray take
+ * @tsplus pipeable fncts.ImmutableArray take
  */
 
-export function take_(self, n) {
-  return tsplus_module_4.slice_(self, 0, n);
+export function take(n) {
+  return self => {
+    return tsplus_module_4.slice(0, n)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray takeLast
+ * @tsplus pipeable fncts.ImmutableArray takeLast
  */
 
-export function takeLast_(as, n) {
-  return isEmpty_1(as) ? tsplus_module_2.empty() : tsplus_module_4.slice_(as, -n);
+export function takeLast(n) {
+  return as => {
+    return isEmpty_1(as) ? tsplus_module_2.empty() : tsplus_module_4.slice(-n)(as);
+  };
 }
-export function takeWhile_(self, p) {
-  const i = spanIndexLeft_1(self, p);
-  const init = Array(i);
+export function takeWhile(p) {
+  return self => {
+    const i = spanIndexLeft_1(p)(self);
+    const init = Array(i);
 
-  for (let j = 0; j < i; j++) {
-    init[j] = self._array[j];
-  }
+    for (let j = 0; j < i; j++) {
+      init[j] = self._array[j];
+    }
 
-  return tsplus_module_2.asImmutableArray(init);
+    return tsplus_module_2.asImmutableArray(init);
+  };
 }
-/**
- * @tsplus getter fncts.ImmutableArray traverseWithIndex
- */
 
-const traverseWithIndex_1 = /*#__PURE__*/tsplus_module_16.mkTraverseWithIndex_()(() => ta => G => f => foldLeftWithIndex_1(ta, G.pure(tsplus_module_2.empty()), (i, fbs, a) => G.zipWith(fbs, f(i, a), (bs, b) => append_1(bs, b))));
-export const traverseWithIndex_ = traverseWithIndex_1;
+function _traverseWithIndex_1(self) {
+  return G => f => foldLeftWithIndex_1(G.pure(tsplus_module_2.empty()), (i, fbs, a) => G.zipWith(f(i, a), (bs, b) => append_1(b)(bs))(fbs))(self);
+}
 /**
  * @tsplus getter fncts.ImmutableArray traverse
  */
 
-const traverse_1 = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
 
-export const traverse_ = traverse_1;
+function _traverse_1(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+export const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
+export const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableArray union
+ * @tsplus pipeable fncts.ImmutableArray union
  */
 
-export function union_(self, that,
+export function union(that,
 /** @tsplus auto */
 E) {
-  return concat_1(self, filter_1(that, a => !elem_1(self, a, E)));
+  return self => {
+    return concat_1(filter_1(a => !elem_1(a, E)(self))(that))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray uniq
+ * @tsplus pipeable fncts.ImmutableArray uniq
  */
 
-export function uniq(self,
+export function uniq(
 /** @tsplus auto */
 E) {
-  if (tsplus_module_5.length(self) === 1) {
-    return self;
-  }
+  return self => {
+    if (tsplus_module_5.length(self) === 1) {
+      return self;
+    }
 
-  const out = [];
-  const len = tsplus_module_5.length(self);
+    const out = [];
+    const len = tsplus_module_5.length(self);
 
-  for (let i = 0; i < len; i++) {
-    const a = self._array[i];
+    for (let i = 0; i < len; i++) {
+      const a = self._array[i];
 
-    if (!elem_1(tsplus_module_2.asImmutableArray(out), a, E)) {
-      out.push(a);
+      if (!elem_1(a, E)(tsplus_module_2.asImmutableArray(out))) {
+        out.push(a);
+      }
     }
-  }
 
-  return tsplus_module_2.asImmutableArray(out);
+    return tsplus_module_2.asImmutableArray(out);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray unprepend
  */
 
 export function unprepend(self) {
-  return tsplus_module_5.isNonEmpty(self) ? tsplus_module_11.just([unsafeGet_1(self, 0), tsplus_module_4.slice_(self, 1)]) : tsplus_module_11.nothing();
+  return tsplus_module_5.isNonEmpty(self) ? tsplus_module_11.just([unsafeGet_1(self, 0), tsplus_module_4.slice(1)(self)]) : tsplus_module_11.nothing();
 }
 /**
  * @tsplus index fncts.ImmutableArray
@@ -1266,54 +1429,62 @@ function unsafeAsMutable_1(self) {
   return self._array;
 }
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeDeleteAt
  */
 
 
-function unsafeDeleteAt_1(self, i) {
-  return mutate_1(self, xs => {
-    xs.splice(i, 1);
-  });
+function unsafeDeleteAt_1(i) {
+  return self => {
+    return mutate_1(xs => {
+      xs.splice(i, 1);
+    })(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeInsertAt
  */
 
 
-function unsafeInsertAt_1(as, i, a) {
-  return mutate_1(as, xs => {
-    xs.splice(i, 0, a);
-  });
+function unsafeInsertAt_1(i, a) {
+  return as => {
+    return mutate_1(xs => {
+      xs.splice(i, 0, a);
+    })(as);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeModifyAt
  */
 
 
-function unsafeModifyAt_1(as, i, f) {
-  const next = f(unsafeGet_1(as, i));
+function unsafeModifyAt_1(i, f) {
+  return as => {
+    const next = f(unsafeGet_1(as, i));
 
-  if (unsafeGet_1(as, i) === next) {
-    return as;
-  }
+    if (unsafeGet_1(as, i) === next) {
+      return as;
+    }
 
-  return mutate_1(as, xs => {
-    xs[i] = next;
-  });
+    return mutate_1(xs => {
+      xs[i] = next;
+    })(as);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeUpdateAt
  */
 
 
-function unsafeUpdateAt_1(as, i, a) {
-  if (unsafeGet_1(as, i) === a) {
-    return as;
-  } else {
-    return mutate_1(as, xs => {
-      xs[i] = a;
-    });
-  }
+function unsafeUpdateAt_1(i, a) {
+  return as => {
+    if (unsafeGet_1(as, i) === a) {
+      return as;
+    } else {
+      return mutate_1(xs => {
+        xs[i] = a;
+      })(as);
+    }
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray unzip
@@ -1332,67 +1503,83 @@ export function unzip(self) {
   return [tsplus_module_2.asImmutableArray(fa), tsplus_module_2.asImmutableArray(fb)];
 }
 /**
- * @tsplus fluent fncts.ImmutableArray updateAt
+ * @tsplus pipeable fncts.ImmutableArray updateAt
  */
 
-export function updateAt_(as, i, a) {
-  return isOutOfBound_1(as, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeUpdateAt_1(as, i, a));
+export function updateAt(i, a) {
+  return as => {
+    return isOutOfBound_1(i)(as) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeUpdateAt_1(i, a)(as));
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray wiltWithIndex
  */
 
-const wiltWithIndex_1 = /*#__PURE__*/tsplus_module_18.makeWiltWithIndex()(_ => self => G => f => G.map(foldLeftWithIndex_1(self, G.pure([[], []]), (i, fbs, a) => G.zipWith(f(i, a), fbs, (eb, r) => tsplus_module_17.match_(eb, b1 => {
-  r[0].push(b1);
-  return r;
-}, b2 => {
-  r[1].push(b2);
-  return r;
-}))), ([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)]));
-export const wiltWithIndex = wiltWithIndex_1;
+function _wiltWithIndex_1(self) {
+  return G => f => G.map(([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)])(foldLeftWithIndex_1(G.pure([[], []]), (i, fbs, a) => G.zipWith(fbs, (eb, r) => tsplus_module_16.match(b1 => {
+    r[0].push(b1);
+    return r;
+  }, b2 => {
+    r[1].push(b2);
+    return r;
+  })(eb))(f(i, a)))(self));
+}
 /**
  * @tsplus getter fncts.ImmutableArray wilt
  */
 
-export const wilt = self => G => f => wiltWithIndex_1(self)(G)((_, a) => f(a));
+
+export function _wilt(self) {
+  return G => f => _wiltWithIndex_1(self)(G)((_, a) => f(a));
+}
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  */
 
-const witherWithIndex_1 = /*#__PURE__*/tsplus_module_18.makeWitherWithIndex()(_ => self => G => f => {
-  return G.map(foldLeftWithIndex_1(self, G.pure([]), (i, b, a) => G.zipWith(f(i, a), b, (maybeB, bs) => {
+function _witherWithIndex_1(self) {
+  return G => f => G.map(bs => tsplus_module_2.asImmutableArray(bs))(foldLeftWithIndex_1(G.pure([]), (i, b, a) => G.zipWith(b, (maybeB, bs) => {
     if (tsplus_module_6.isJust(maybeB)) {
       bs.push(maybeB.value);
     }
 
     return bs;
-  })), bs => tsplus_module_2.asImmutableArray(bs));
-});
-export const witherWithIndex = witherWithIndex_1;
+  })(f(i, a)))(self));
+}
 /**
  * @tsplus getter fncts.ImmutableArray wither
  */
 
-export const wither = self => G => f => witherWithIndex_1(self)(G)((_, a) => f(a));
+
+export function _wither(self) {
+  return G => f => _witherWithIndex_1(self)(G)((_, a) => f(a));
+}
+export const wiltWithIndex = G => f => self => _wiltWithIndex_1(self)(G)(f);
+export const wilt = G => f => self => _wiltWithIndex_1(self)(G)((_, a) => f(a));
+export const witherWithIndex = G => f => self => _witherWithIndex_1(self)(G)(f);
+export const wither = G => f => self => _witherWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableArray zip
+ * @tsplus pipeable fncts.ImmutableArray zip
  */
 
-export function zip_(self, that) {
-  return zipWith_1(self, that, tuple);
+export function zip(that) {
+  return self => {
+    return zipWith_1(that, tuple)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray zipWith
+ * @tsplus pipeable fncts.ImmutableArray zipWith
  */
 
-function zipWith_1(self, fb, f) {
-  const len = Math.min(tsplus_module_5.length(self), tsplus_module_5.length(fb));
-  const fc = Array(len);
+function zipWith_1(fb, f) {
+  return self => {
+    const len = Math.min(tsplus_module_5.length(self), tsplus_module_5.length(fb));
+    const fc = Array(len);
 
-  for (let i = 0; i < len; i++) {
-    fc[i] = f(self._array[i], fb._array[i]);
-  }
+    for (let i = 0; i < len; i++) {
+      fc[i] = f(self._array[i], fb._array[i]);
+    }
 
-  return tsplus_module_2.asImmutableArray(fc);
+    return tsplus_module_2.asImmutableArray(fc);
+  };
 }
 //# sourceMappingURL=api.mjs.map