@fncts/base 0.0.20 → 0.0.21

package/_cjs/collection/immutable/ImmutableArray/api.cjs

@@ -3,93 +3,96 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.alignWith_ = void 0;
-exports.align_ = align_;
-exports.alt_ = alt_;
-exports.ap_ = ap_;
-exports.append_ = void 0;
+exports._traverseWithIndex = exports._traverse = void 0;
+exports._wilt = _wilt;
+exports._wiltWithIndex = void 0;
+exports._wither = _wither;
+exports._witherWithIndex = void 0;
+exports.align = align;
+exports.alignWith = void 0;
+exports.alt = alt;
+exports.ap = ap;
+exports.append = void 0;
 exports.chainRecBreadthFirst = chainRecBreadthFirst;
 exports.chainRecDepthFirst = chainRecDepthFirst;
 exports.chop = void 0;
-exports.chopSelf = chopSelf;
-exports.chop_ = chop_;
-exports.collectWhile_ = collectWhile_;
+exports.collectWhile = collectWhile;
 exports.comprehension = comprehension;
-exports.crossWith_ = exports.concat_ = void 0;
-exports.cross_ = cross_;
-exports.deleteAt_ = deleteAt_;
-exports.difference_ = difference_;
-exports.dropLastWhile_ = dropLastWhile_;
-exports.dropLast_ = dropLast_;
-exports.dropWhile_ = dropWhile_;
-exports.drop_ = drop_;
-exports.everyWithIndex_ = exports.elem_ = void 0;
-exports.every_ = every_;
-exports.exists_ = exists_;
-exports.filterMapWithIndex_ = void 0;
-exports.filterMap_ = filterMap_;
-exports.filter_ = exports.filterWithIndex_ = void 0;
-exports.findIndex_ = findIndex_;
-exports.findLastIndex_ = findLastIndex_;
-exports.findLastMapWithIndex_ = void 0;
-exports.findLastMap_ = findLastMap_;
-exports.findLast_ = findLast_;
-exports.findMapWithIndex_ = void 0;
-exports.findMap_ = findMap_;
-exports.findWithIndex_ = void 0;
-exports.find_ = find_;
-exports.fold = exports.flatten = exports.flatMap_ = exports.flatMapWithIndex_ = void 0;
-exports.foldLeftWhile_ = foldLeftWhile_;
-exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = exports.foldLeftWithIndexWhile_ = void 0;
-exports.foldMap_ = foldMap_;
-exports.foldRightWhile_ = foldRightWhile_;
-exports.foldRightWithIndex_ = exports.foldRightWithIndexWhile_ = void 0;
-exports.foldRight_ = foldRight_;
-exports.get_ = exports.forEach_ = void 0;
+exports.concat = void 0;
+exports.cross = cross;
+exports.crossWith = void 0;
+exports.deleteAt = deleteAt;
+exports.difference = difference;
+exports.drop = drop;
+exports.dropLast = dropLast;
+exports.dropLastWhile = dropLastWhile;
+exports.dropWhile = dropWhile;
+exports.elem = void 0;
+exports.every = every;
+exports.everyWithIndex = void 0;
+exports.exists = exists;
+exports.filter = void 0;
+exports.filterMap = filterMap;
+exports.filterWithIndex = exports.filterMapWithIndex = void 0;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.findLastMap = findLastMap;
+exports.findLastMapWithIndex = void 0;
+exports.findMap = findMap;
+exports.foldLeft = exports.fold = exports.flatten = exports.flatMapWithIndex = exports.flatMap = exports.findWithIndex = exports.findMapWithIndex = void 0;
+exports.foldLeftWhile = foldLeftWhile;
+exports.foldLeftWithIndexWhile = exports.foldLeftWithIndex = void 0;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = void 0;
+exports.foldRight = foldRight;
+exports.foldRightWhile = foldRightWhile;
+exports.get = exports.forEach = exports.foldRightWithIndexWhile = exports.foldRightWithIndex = void 0;
 exports.group = group;
-exports.groupBy_ = groupBy_;
+exports.groupBy = groupBy;
 exports.head = head;
 exports.init = init;
-exports.insertAt_ = insertAt_;
-exports.intersection_ = intersection_;
-exports.intersperse_ = intersperse_;
-exports.isOutOfBound_ = exports.isEmpty = void 0;
+exports.insertAt = insertAt;
+exports.intersection = intersection;
+exports.intersperse = intersperse;
+exports.isOutOfBound = exports.isEmpty = void 0;
 exports.join = join;
 exports.last = last;
 exports.lefts = lefts;
 exports.length = length;
-exports.mapAccum_ = mapAccum_;
-exports.map_ = exports.mapWithIndex_ = void 0;
-exports.modifyAt_ = modifyAt_;
-exports.partitionMapWithIndex_ = exports.mutate_ = exports.mutableClone = void 0;
-exports.partitionMap_ = partitionMap_;
-exports.partitionWithIndex_ = void 0;
-exports.partition_ = partition_;
-exports.prepend_ = exports.prependAll_ = void 0;
+exports.map = void 0;
+exports.mapAccum = mapAccum;
+exports.mapWithIndex = void 0;
+exports.modifyAt = modifyAt;
+exports.mutate = exports.mutableClone = void 0;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.prependAll = exports.prepend = exports.partitionWithIndex = exports.partitionMapWithIndex = void 0;
 exports.reverse = reverse;
 exports.rights = rights;
-exports.rotate_ = void 0;
-exports.scanLeft_ = scanLeft_;
-exports.scanRight_ = scanRight_;
+exports.rotate = void 0;
+exports.scanLeft = scanLeft;
+exports.scanRight = scanRight;
 exports.sort = void 0;
 exports.sortBy = sortBy;
-exports.spanIndexRight_ = exports.spanIndexLeft_ = void 0;
-exports.spanLeft_ = spanLeft_;
-exports.spanRight_ = spanRight_;
+exports.spanIndexRight = exports.spanIndexLeft = void 0;
+exports.spanLeft = spanLeft;
+exports.spanRight = spanRight;
 exports.tail = tail;
-exports.takeLast_ = takeLast_;
-exports.takeWhile_ = takeWhile_;
-exports.take_ = take_;
-exports.traverse_ = exports.traverseWithIndex_ = void 0;
-exports.union_ = union_;
+exports.take = take;
+exports.takeLast = takeLast;
+exports.takeWhile = takeWhile;
+exports.traverseWithIndex = exports.traverse = void 0;
+exports.union = union;
 exports.uniq = uniq;
 exports.unprepend = unprepend;
-exports.unsafeAsMutable = void 0;
-exports.unsafeUpdateAt_ = exports.unsafeModifyAt_ = exports.unsafeInsertAt_ = exports.unsafeGet = exports.unsafeDeleteAt_ = void 0;
+exports.unsafeUpdateAt = exports.unsafeModifyAt = exports.unsafeInsertAt = exports.unsafeGet = exports.unsafeDeleteAt = exports.unsafeAsMutable = void 0;
 exports.unzip = unzip;
-exports.updateAt_ = updateAt_;
-exports.zipWith_ = exports.witherWithIndex = exports.wither = exports.wiltWithIndex = exports.wilt = void 0;
-exports.zip_ = zip_;
+exports.updateAt = updateAt;
+exports.witherWithIndex = exports.wither = exports.wiltWithIndex = exports.wilt = void 0;
+exports.zip = zip;
+exports.zipWith = void 0;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/These/constructors"));
 
@@ -121,11 +124,7 @@ var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/requir
 
 var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Ord/instances"));
 
-var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/TraversableWithIndex"));
-
-var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
-
-var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/WitherableWithIndex"));
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
 
 var _function = /*#__PURE__*/require("@fncts/base/data/function");
 
@@ -135,181 +134,205 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const alignWith_ = alignWith_1;
-exports.alignWith_ = alignWith_;
-const append_ = append_1;
-exports.append_ = append_;
-const crossWith_ = crossWith_1;
-exports.crossWith_ = crossWith_;
-const flatMapWithIndex_ = flatMapWithIndex_1;
-exports.flatMapWithIndex_ = flatMapWithIndex_;
-const flatMap_ = flatMap_1;
-exports.flatMap_ = flatMap_;
+const alignWith = alignWith_1;
+exports.alignWith = alignWith;
+const append = append_1;
+exports.append = append;
+const crossWith = crossWith_1;
+exports.crossWith = crossWith;
+const flatMapWithIndex = flatMapWithIndex_1;
+exports.flatMapWithIndex = flatMapWithIndex;
+const flatMap = flatMap_1;
+exports.flatMap = flatMap;
 const flatten = flatten_1;
 exports.flatten = flatten;
-const concat_ = concat_1;
-exports.concat_ = concat_;
-const elem_ = elem_1;
-exports.elem_ = elem_;
-const everyWithIndex_ = everyWithIndex_1;
-exports.everyWithIndex_ = everyWithIndex_;
-const filter_ = filter_1;
-exports.filter_ = filter_;
-const filterWithIndex_ = filterWithIndex_1;
-exports.filterWithIndex_ = filterWithIndex_;
-const filterMapWithIndex_ = filterMapWithIndex_1;
-exports.filterMapWithIndex_ = filterMapWithIndex_;
-const findWithIndex_ = findWithIndex_1;
-exports.findWithIndex_ = findWithIndex_;
-const findMapWithIndex_ = findMapWithIndex_1;
-exports.findMapWithIndex_ = findMapWithIndex_;
-const findLastMapWithIndex_ = findLastMapWithIndex_1;
-exports.findLastMapWithIndex_ = findLastMapWithIndex_;
-const foldLeftWithIndex_ = foldLeftWithIndex_1;
-exports.foldLeftWithIndex_ = foldLeftWithIndex_;
-const foldLeft_ = foldLeft_1;
-exports.foldLeft_ = foldLeft_;
-const foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_1;
-exports.foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_;
+const chop = chop_1;
+exports.chop = chop;
+const concat = concat_1;
+exports.concat = concat;
+const elem = elem_1;
+exports.elem = elem;
+const everyWithIndex = everyWithIndex_1;
+exports.everyWithIndex = everyWithIndex;
+const filter = filter_1;
+exports.filter = filter;
+const filterWithIndex = filterWithIndex_1;
+exports.filterWithIndex = filterWithIndex;
+const filterMapWithIndex = filterMapWithIndex_1;
+exports.filterMapWithIndex = filterMapWithIndex;
+const findWithIndex = findWithIndex_1;
+exports.findWithIndex = findWithIndex;
+const findMapWithIndex = findMapWithIndex_1;
+exports.findMapWithIndex = findMapWithIndex;
+const findLastMapWithIndex = findLastMapWithIndex_1;
+exports.findLastMapWithIndex = findLastMapWithIndex;
+const foldLeftWithIndex = foldLeftWithIndex_1;
+exports.foldLeftWithIndex = foldLeftWithIndex;
+const foldLeft = foldLeft_1;
+exports.foldLeft = foldLeft;
+const foldLeftWithIndexWhile = foldLeftWithIndexWhile_1;
+exports.foldLeftWithIndexWhile = foldLeftWithIndexWhile;
 const fold = fold_1;
 exports.fold = fold;
-const foldMapWithIndex_ = foldMapWithIndex_1;
-exports.foldMapWithIndex_ = foldMapWithIndex_;
-const foldRightWithIndex_ = foldRightWithIndex_1;
-exports.foldRightWithIndex_ = foldRightWithIndex_;
-const foldRightWithIndexWhile_ = foldRightWithIndexWhile_1;
-exports.foldRightWithIndexWhile_ = foldRightWithIndexWhile_;
-const forEach_ = forEach_1;
-exports.forEach_ = forEach_;
-const get_ = get_1;
-exports.get_ = get_;
+const foldMapWithIndex = foldMapWithIndex_1;
+exports.foldMapWithIndex = foldMapWithIndex;
+const foldRightWithIndex = foldRightWithIndex_1;
+exports.foldRightWithIndex = foldRightWithIndex;
+const foldRightWithIndexWhile = foldRightWithIndexWhile_1;
+exports.foldRightWithIndexWhile = foldRightWithIndexWhile;
+const forEach = forEach_1;
+exports.forEach = forEach;
+const get = get_1;
+exports.get = get;
 const isEmpty = isEmpty_1;
 exports.isEmpty = isEmpty;
-const isOutOfBound_ = isOutOfBound_1;
-exports.isOutOfBound_ = isOutOfBound_;
-const map_ = map_1;
-exports.map_ = map_;
-const mapWithIndex_ = mapWithIndex_1;
-exports.mapWithIndex_ = mapWithIndex_;
-const mutate_ = mutate_1;
-exports.mutate_ = mutate_;
+const isOutOfBound = isOutOfBound_1;
+exports.isOutOfBound = isOutOfBound;
+const map = map_1;
+exports.map = map;
+const mapWithIndex = mapWithIndex_1;
+exports.mapWithIndex = mapWithIndex;
+const mutate = mutate_1;
+exports.mutate = mutate;
 const mutableClone = mutableClone_1;
 exports.mutableClone = mutableClone;
-const partitionWithIndex_ = partitionWithIndex_1;
-exports.partitionWithIndex_ = partitionWithIndex_;
-const partitionMapWithIndex_ = partitionMapWithIndex_1;
-exports.partitionMapWithIndex_ = partitionMapWithIndex_;
-const prepend_ = prepend_1;
-exports.prepend_ = prepend_;
-const prependAll_ = prependAll_1;
-exports.prependAll_ = prependAll_;
-const rotate_ = rotate_1;
-exports.rotate_ = rotate_;
+const partitionWithIndex = partitionWithIndex_1;
+exports.partitionWithIndex = partitionWithIndex;
+const partitionMapWithIndex = partitionMapWithIndex_1;
+exports.partitionMapWithIndex = partitionMapWithIndex;
+const prepend = prepend_1;
+exports.prepend = prepend;
+const prependAll = prependAll_1;
+exports.prependAll = prependAll;
+const rotate = rotate_1;
+exports.rotate = rotate;
 const sort = sort_1;
 exports.sort = sort;
-const spanIndexLeft_ = spanIndexLeft_1;
-exports.spanIndexLeft_ = spanIndexLeft_;
-const spanIndexRight_ = spanIndexRight_1;
-exports.spanIndexRight_ = spanIndexRight_;
+const spanIndexLeft = spanIndexLeft_1;
+exports.spanIndexLeft = spanIndexLeft;
+const spanIndexRight = spanIndexRight_1;
+exports.spanIndexRight = spanIndexRight;
+const _traverseWithIndex = _traverseWithIndex_1;
+exports._traverseWithIndex = _traverseWithIndex;
+const _traverse = _traverse_1;
+exports._traverse = _traverse;
 const unsafeGet = unsafeGet_1;
 exports.unsafeGet = unsafeGet;
 const unsafeAsMutable = unsafeAsMutable_1;
 exports.unsafeAsMutable = unsafeAsMutable;
-const unsafeDeleteAt_ = unsafeDeleteAt_1;
-exports.unsafeDeleteAt_ = unsafeDeleteAt_;
-const unsafeInsertAt_ = unsafeInsertAt_1;
-exports.unsafeInsertAt_ = unsafeInsertAt_;
-const unsafeModifyAt_ = unsafeModifyAt_1;
-exports.unsafeModifyAt_ = unsafeModifyAt_;
-const unsafeUpdateAt_ = unsafeUpdateAt_1;
-exports.unsafeUpdateAt_ = unsafeUpdateAt_;
-const zipWith_ = zipWith_1;
-exports.zipWith_ = zipWith_;
-
-/**
- * @tsplus fluent 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);
-
-  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]));
+const unsafeDeleteAt = unsafeDeleteAt_1;
+exports.unsafeDeleteAt = unsafeDeleteAt;
+const unsafeInsertAt = unsafeInsertAt_1;
+exports.unsafeInsertAt = unsafeInsertAt;
+const unsafeModifyAt = unsafeModifyAt_1;
+exports.unsafeModifyAt = unsafeModifyAt;
+const unsafeUpdateAt = unsafeUpdateAt_1;
+exports.unsafeUpdateAt = unsafeUpdateAt;
+const _wiltWithIndex = _wiltWithIndex_1;
+exports._wiltWithIndex = _wiltWithIndex;
+const _witherWithIndex = _witherWithIndex_1;
+exports._witherWithIndex = _witherWithIndex;
+const zipWith = zipWith_1;
+exports.zipWith = zipWith;
+
+/**
+ * @tsplus pipeable fncts.ImmutableArray alignWith
+ */
+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]));
     }
-  } 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
  */
 
 
-function align_(self, fb) {
-  return alignWith_1(self, fb, _function.identity);
+function align(fb) {
+  return self => {
+    return alignWith_1(fb, _function.identity)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray alt
+ * @tsplus pipeable fncts.ImmutableArray alt
  */
 
 
-function alt_(self, that) {
-  return concat_1(self, that());
+function alt(that) {
+  return self => {
+    return concat_1(that())(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray ap
+ * @tsplus pipeable fncts.ImmutableArray ap
  */
 
 
-function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, f));
+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
  */
 
 
-function cross_(self, fb) {
-  return crossWith_1(self, fb, (a, b) => tsplus_module_3.make(a, b));
+function cross(fb) {
+  return self => {
+    return crossWith_1(fb, (a, b) => tsplus_module_3.make(a, b))(self);
+  };
 }
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
@@ -317,7 +340,7 @@ function cross_(self, fb) {
 
 
 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) {
@@ -349,7 +372,7 @@ 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);
     }
@@ -366,48 +389,52 @@ 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
@@ -415,59 +442,59 @@ function flatMap_1(self, f) {
 
 
 function flatten_1(self) {
-  return flatMap_1(self, _function.identity);
+  return flatMap_1(_function.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
  */
 
 
-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);
+  };
 }
-
-const chop = f => as => chop_(as, f);
 /**
- * @tsplus fluent fncts.ImmutableArray collectWhile
+ * @tsplus pipeable fncts.ImmutableArray collectWhile
  */
 
 
-exports.chop = chop;
-
-function collectWhile_(as, f) {
-  const result = [];
+function collectWhile(f) {
+  return as => {
+    const result = [];
 
-  for (let i = 0; i < tsplus_module_5.length(as); i++) {
-    const o = f(as._array[i]);
+    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;
+      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)));
   }
 }
 
@@ -475,429 +502,507 @@ 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
  */
 
 
-function deleteAt_(as, i) {
-  return isOutOfBound_1(as, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeDeleteAt_1(as, i));
+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
  */
 
 
-function difference_(self, ys,
+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
  */
 
 
-function drop_(self, n) {
-  return tsplus_module_4.slice_(self, n);
+function drop(n) {
+  return self => {
+    return tsplus_module_4.slice(n)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray dropLast
+ * @tsplus pipeable fncts.ImmutableArray dropLast
  */
 
 
-function dropLast_(self, n) {
-  return tsplus_module_4.slice_(self, 0, tsplus_module_5.length(self) - n);
+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
  */
 
 
-function dropWhile_(self, p) {
-  return tsplus_module_4.slice_(self, spanIndexLeft_1(self, p));
+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
  */
 
 
-function dropLastWhile_(as, p) {
-  return tsplus_module_4.slice_(as, 0, spanIndexRight_1(as, p) + 1);
+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;
+  };
 }
 
-function every_(self, p) {
-  return everyWithIndex_1(self, (_, a) => p(a));
+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
  */
 
 
-function exists_(self, p) {
-  let result = false;
-  let i = 0;
+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
  */
 
 
-function filterMap_(self, f) {
-  return filterMapWithIndex_1(self, (_, a) => f(a));
+function filterMap(f) {
+  return self => {
+    return filterMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 
-function find_(self, p) {
-  return findWithIndex_1(self, (_, a) => p(a));
+function find(p) {
+  return self => {
+    return findWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray findIndex
+ * @tsplus pipeable fncts.ImmutableArray findIndex
  */
 
 
-function findIndex_(as, predicate) {
-  return findMapWithIndex_1(as, (i, a) => predicate(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing());
+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
  */
 
 
-function findMap_(as, f) {
-  return findMapWithIndex_1(as, (_, a) => f(a));
+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();
+  };
 }
 
-function findLast_(as, p) {
-  const len = tsplus_module_5.length(as);
+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
  */
 
 
-function findLastIndex_(self, p) {
-  return findLastMapWithIndex_1(self, (i, a) => p(a) ? tsplus_module_11.just(i) : tsplus_module_11.nothing());
+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
  */
 
 
-function findLastMap_(as, f) {
-  return findLastMapWithIndex_1(as, (_, a) => f(a));
+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
  */
 
 
-function foldLeftWhile_(self, b, p, f) {
-  return foldLeftWithIndexWhile_1(self, b, p, (_, b, a) => f(b, a));
+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
  */
 
 
-function foldMap_(self, f,
+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
  */
 
 
-function foldRight_(self, b, f) {
-  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+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
  */
 
 
-function foldRightWhile_(self, b, p, f) {
-  return foldRightWithIndexWhile_1(self, b, p, (_, a, b) => f(a, b));
+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
+ */
+
 
 function group(E) {
-  return chop(self => {
+  return chop_1(self => {
     const h = self._array[0];
     const out = [h];
     let i = 1;
@@ -912,37 +1017,31 @@ 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
- */
-
-
-function chopSelf(self, E) {
-  return group(E)(self);
-}
-/**
- * @tsplus fluent fncts.ImmutableArray groupBy
+ * @tsplus pipeable fncts.ImmutableArray groupBy
  */
 
 
-function groupBy_(self, f) {
-  const out = {};
+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
@@ -959,30 +1058,40 @@ function head(self) {
 
 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
  */
 
 
-function insertAt_(self, i, a) {
-  return isOutOfBound_1(self, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeInsertAt_1(self, i, a));
+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
  */
 
 
-function intersection_(self, that,
+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);
+  };
 }
+/**
+ * @tsplus pipeable fncts.ImmutableArray intersperse
+ */
 
-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));
+
+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
@@ -993,20 +1102,24 @@ 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
  */
 
 
-function join(self, separator) {
-  return self._array.join(separator);
+function join(separator) {
+  return self => {
+    return self._array.join(separator);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableArray last
@@ -1014,7 +1127,7 @@ function join(self, separator) {
 
 
 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
@@ -1046,62 +1159,72 @@ 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
  */
 
 
-function mapAccum_(self, s, f) {
-  const bs = Array(tsplus_module_5.length(self));
-  let state = s;
+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
  */
 
 
-function modifyAt_(self, i, f) {
-  return isOutOfBound_1(self, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeModifyAt_1(self, i, f));
+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
@@ -1109,97 +1232,108 @@ 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)];
+  };
 }
 
-function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+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
  */
 
 
-function partitionMap_(self, f) {
-  return partitionMapWithIndex_1(self, (_, a) => f(a));
+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
@@ -1243,139 +1377,157 @@ 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
  */
 
 
-function scanLeft_(self, b, f) {
-  const l = tsplus_module_5.length(self);
-  const r = Array(l + 1);
-  r[0] = b;
+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
  */
 
 
-function scanRight_(self, b, f) {
-  const l = tsplus_module_5.length(self);
-  const r = Array(l + 1);
-  r[l] = b;
+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
  */
 
 
-function sortBy(self, Os) {
-  return sort_1(self, fold_1(Os, tsplus_module_15.getMonoid()));
+function sortBy(Os) {
+  return self => {
+    return sort_1(fold_1(tsplus_module_15.getMonoid())(Os))(self);
+  };
 }
 
-function spanLeft_(self, p) {
-  const i = spanIndexLeft_1(self, p);
-  const init = Array(i);
+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)];
+  };
 }
 
-function spanRight_(self, p) {
-  const i = spanIndexRight_1(self, p);
-  const l = tsplus_module_5.length(self);
-  const tail = Array(l - i - 1);
+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
@@ -1383,86 +1535,99 @@ function spanIndexRight_1(as, predicate) {
 
 
 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
  */
 
 
-function take_(self, n) {
-  return tsplus_module_4.slice_(self, 0, n);
+function take(n) {
+  return self => {
+    return tsplus_module_4.slice(0, n)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableArray takeLast
+ * @tsplus pipeable fncts.ImmutableArray takeLast
  */
 
 
-function takeLast_(as, n) {
-  return isEmpty_1(as) ? tsplus_module_2.empty() : tsplus_module_4.slice_(as, -n);
+function takeLast(n) {
+  return as => {
+    return isEmpty_1(as) ? tsplus_module_2.empty() : tsplus_module_4.slice(-n)(as);
+  };
 }
 
-function takeWhile_(self, p) {
-  const i = spanIndexLeft_1(self, p);
-  const init = Array(i);
+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))));
-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
  */
 
-exports.traverseWithIndex_ = traverseWithIndex_;
 
-const traverse_1 = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+function _traverse_1(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
+
+exports.traverseWithIndex = traverseWithIndex;
 
-const traverse_ = traverse_1;
+const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableArray union
+ * @tsplus pipeable fncts.ImmutableArray union
  */
 
-exports.traverse_ = traverse_;
 
-function union_(self, that,
+exports.traverse = traverse;
+
+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
  */
 
 
-function uniq(self,
+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
@@ -1470,7 +1635,7 @@ E) {
 
 
 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
@@ -1489,54 +1654,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
@@ -1555,79 +1728,100 @@ function unzip(self) {
   return [tsplus_module_2.asImmutableArray(fa), tsplus_module_2.asImmutableArray(fb)];
 }
 /**
- * @tsplus fluent fncts.ImmutableArray updateAt
+ * @tsplus pipeable fncts.ImmutableArray updateAt
  */
 
 
-function updateAt_(as, i, a) {
-  return isOutOfBound_1(as, i) ? tsplus_module_11.nothing() : tsplus_module_11.just(unsafeUpdateAt_1(as, i, a));
+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)]));
-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
  */
 
-exports.wiltWithIndex = wiltWithIndex;
 
-const wilt = self => G => f => wiltWithIndex_1(self)(G)((_, a) => f(a));
+function _wilt(self) {
+  return G => f => _wiltWithIndex_1(self)(G)((_, a) => f(a));
+}
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  */
 
 
-exports.wilt = wilt;
-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));
-});
-const witherWithIndex = witherWithIndex_1;
+  })(f(i, a)))(self));
+}
 /**
  * @tsplus getter fncts.ImmutableArray wither
  */
 
+
+function _wither(self) {
+  return G => f => _witherWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+const wiltWithIndex = G => f => self => _wiltWithIndex_1(self)(G)(f);
+
+exports.wiltWithIndex = wiltWithIndex;
+
+const wilt = G => f => self => _wiltWithIndex_1(self)(G)((_, a) => f(a));
+
+exports.wilt = wilt;
+
+const witherWithIndex = G => f => self => _witherWithIndex_1(self)(G)(f);
+
 exports.witherWithIndex = witherWithIndex;
 
-const wither = self => G => f => witherWithIndex_1(self)(G)((_, a) => f(a));
+const wither = G => f => self => _witherWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableArray zip
+ * @tsplus pipeable fncts.ImmutableArray zip
  */
 
 
 exports.wither = wither;
 
-function zip_(self, that) {
-  return zipWith_1(self, that, _function.tuple);
+function zip(that) {
+  return self => {
+    return zipWith_1(that, _function.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.cjs.map