@fncts/base 0.0.20 → 0.0.21

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

@@ -3,33 +3,34 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.alignWith_ = void 0;
-exports.align_ = align_;
+exports._traverse = _traverse;
+exports._traverseWithIndex = void 0;
+exports.align = align;
+exports.alignWith = void 0;
 exports.ap_ = ap_;
-exports.chop_ = exports.append_ = void 0;
-exports.chunksOf_ = chunksOf_;
-exports.concat_ = concat_;
-exports.crossWith_ = void 0;
-exports.cross_ = cross_;
-exports.flatMap_ = exports.flatMapWithIndex_ = exports.elem_ = void 0;
+exports.chop = exports.append = void 0;
+exports.chunksOf = chunksOf;
+exports.concat = concat;
+exports.cross = cross;
+exports.flatMapWithIndex = exports.flatMap = exports.elem = exports.crossWith = void 0;
 exports.flatten = flatten;
-exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = void 0;
-exports.foldMap_ = foldMap_;
-exports.foldRightWithIndex_ = void 0;
-exports.foldRight_ = foldRight_;
-exports.fold_ = fold_;
-exports.group = void 0;
+exports.fold = fold;
+exports.foldLeftWithIndex = exports.foldLeft = void 0;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = void 0;
+exports.foldRight = foldRight;
+exports.group = exports.foldRightWithIndex = void 0;
 exports.groupSort = groupSort;
-exports.isOutOfBound_ = isOutOfBound_;
-exports.map_ = exports.mapWithIndex_ = void 0;
+exports.isOutOfBound = isOutOfBound;
+exports.mapWithIndex = exports.map = void 0;
 exports.max = max;
 exports.min = min;
 exports.mutableClone = mutableClone;
-exports.prepend_ = prepend_;
+exports.prepend = prepend;
 exports.reverse = reverse;
-exports.traverseWithIndex = exports.traverse = exports.splitAt_ = exports.sort = void 0;
+exports.traverseWithIndex = exports.traverse = exports.splitAt = exports.sort = void 0;
 exports.uniq = uniq;
-exports.zipWith_ = zipWith_;
+exports.zipWith = zipWith;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition"));
 
@@ -49,8 +50,6 @@ var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require
 
 var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/ImmutableArray/constructors"));
 
-var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/TraversableWithIndex"));
-
 var _function = /*#__PURE__*/require("@fncts/base/data/function");
 
 var P = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass"));
@@ -59,231 +58,257 @@ 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 append_ = append_1;
-exports.append_ = append_;
-const alignWith_ = alignWith_1;
-exports.alignWith_ = alignWith_;
-const flatMap_ = flatMap_1;
-exports.flatMap_ = flatMap_;
-const flatMapWithIndex_ = flatMapWithIndex_1;
-exports.flatMapWithIndex_ = flatMapWithIndex_;
-const chop_ = chop_1;
-exports.chop_ = chop_;
-const crossWith_ = crossWith_1;
-exports.crossWith_ = crossWith_;
-const elem_ = elem_1;
-exports.elem_ = elem_;
-const foldLeft_ = foldLeft_1;
-exports.foldLeft_ = foldLeft_;
-const foldLeftWithIndex_ = foldLeftWithIndex_1;
-exports.foldLeftWithIndex_ = foldLeftWithIndex_;
-const foldMapWithIndex_ = foldMapWithIndex_1;
-exports.foldMapWithIndex_ = foldMapWithIndex_;
-const foldRightWithIndex_ = foldRightWithIndex_1;
-exports.foldRightWithIndex_ = foldRightWithIndex_;
+const append = append_1;
+exports.append = append;
+const alignWith = alignWith_1;
+exports.alignWith = alignWith;
+const flatMap = flatMap_1;
+exports.flatMap = flatMap;
+const flatMapWithIndex = flatMapWithIndex_1;
+exports.flatMapWithIndex = flatMapWithIndex;
+const chop = chop_1;
+exports.chop = chop;
+const crossWith = crossWith_1;
+exports.crossWith = crossWith;
+const elem = elem_1;
+exports.elem = elem;
+const foldLeft = foldLeft_1;
+exports.foldLeft = foldLeft;
+const foldLeftWithIndex = foldLeftWithIndex_1;
+exports.foldLeftWithIndex = foldLeftWithIndex;
+const foldMapWithIndex = foldMapWithIndex_1;
+exports.foldMapWithIndex = foldMapWithIndex;
+const foldRightWithIndex = foldRightWithIndex_1;
+exports.foldRightWithIndex = foldRightWithIndex;
 const group = group_1;
 exports.group = group;
-const map_ = map_1;
-exports.map_ = map_;
-const mapWithIndex_ = mapWithIndex_1;
-exports.mapWithIndex_ = mapWithIndex_;
-const splitAt_ = splitAt_1;
-exports.splitAt_ = splitAt_;
+const map = map_1;
+exports.map = map;
+const mapWithIndex = mapWithIndex_1;
+exports.mapWithIndex = mapWithIndex;
+const splitAt = splitAt_1;
+exports.splitAt = splitAt;
 const sort = sort_1;
 exports.sort = sort;
+const _traverseWithIndex = _traverseWithIndex_1;
+exports._traverseWithIndex = _traverseWithIndex;
 
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray ap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray ap
  */
-function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, a => f(a)));
+function ap_(fa) {
+  return self => {
+    return flatMap_1(f => map_1(a => f(a))(fa))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray append
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray append
  */
 
 
-function append_1(self, last) {
-  const len = tsplus_module_1.length(self);
-  const r = Array(len + 1);
-  r[len] = last;
+function append_1(last) {
+  return self => {
+    const len = tsplus_module_1.length(self);
+    const r = Array(len + 1);
+    r[len] = last;
 
-  for (let i = 0; i < len; i++) {
-    r[i] = self._array[i];
-  }
+    for (let i = 0; i < len; i++) {
+      r[i] = self._array[i];
+    }
 
-  return tsplus_module_2.unsafeAsNonEmptyArray(r);
+    return tsplus_module_2.unsafeAsNonEmptyArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray align
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray alignWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray alignWith
  */
 
 
-function alignWith_1(self, fb, f) {
-  const minlen = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
-  const maxlen = Math.max(tsplus_module_1.length(self), tsplus_module_1.length(fb));
-  const ret = (0, tsplus_module_2.allocWithHead)(f(tsplus_module_4.both(tsplus_module_3.head(self), tsplus_module_3.head(fb))), maxlen);
-
-  for (let i = 1; i < minlen; i++) {
-    ret[i] = f(tsplus_module_4.both(self._array[i], fb._array[i]));
-  }
+function alignWith_1(fb, f) {
+  return self => {
+    const minlen = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
+    const maxlen = Math.max(tsplus_module_1.length(self), tsplus_module_1.length(fb));
+    const ret = (0, tsplus_module_2.allocWithHead)(f(tsplus_module_4.both(tsplus_module_3.head(self), tsplus_module_3.head(fb))), maxlen);
 
-  if (minlen === maxlen) {
-    return tsplus_module_2.from(ret);
-  } else if (tsplus_module_1.length(self) > tsplus_module_1.length(fb)) {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(tsplus_module_4.left(self._array[i]));
+    for (let i = 1; i < minlen; i++) {
+      ret[i] = f(tsplus_module_4.both(self._array[i], fb._array[i]));
     }
-  } else {
-    for (let i = minlen; i < maxlen; i++) {
-      ret[i] = f(tsplus_module_4.right(fb._array[i]));
+
+    if (minlen === maxlen) {
+      return tsplus_module_2.from(ret);
+    } else if (tsplus_module_1.length(self) > tsplus_module_1.length(fb)) {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_4.left(self._array[i]));
+      }
+    } else {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_4.right(fb._array[i]));
+      }
     }
-  }
 
-  return tsplus_module_2.from(ret);
+    return tsplus_module_2.from(ret);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray flatMap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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 fluent fncts.ImmutableNonEmptyArray flatMapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray flatMapWithIndex
  */
 
 
-function flatMapWithIndex_1(self, f) {
-  let outLen = 1;
-  const len = tsplus_module_1.length(self);
-  const temp = (0, tsplus_module_2.allocWithHead)(f(0, self._array[0]), len);
+function flatMapWithIndex_1(f) {
+  return self => {
+    let outLen = 1;
+    const len = tsplus_module_1.length(self);
+    const temp = (0, tsplus_module_2.allocWithHead)(f(0, self._array[0]), len);
 
-  for (let i = 1; i < len; i++) {
-    const e = self._array[i];
-    const arr = f(i, e);
-    outLen += tsplus_module_1.length(arr);
-    temp[i] = arr;
-  }
+    for (let i = 1; i < len; i++) {
+      const e = self._array[i];
+      const arr = f(i, e);
+      outLen += tsplus_module_1.length(arr);
+      temp[i] = arr;
+    }
 
-  const out = Array(outLen);
-  const out0 = temp[0];
-  const len0 = tsplus_module_1.length(temp[0]);
+    const out = Array(outLen);
+    const out0 = temp[0];
+    const len0 = tsplus_module_1.length(temp[0]);
 
-  for (let j = 0; j < len0; j++) {
-    out[j] = out0._array[j];
-  }
+    for (let j = 0; j < len0; j++) {
+      out[j] = out0._array[j];
+    }
 
-  let start = tsplus_module_1.length(temp[0]);
+    let start = tsplus_module_1.length(temp[0]);
 
-  for (let i = 1; i < len; i++) {
-    const arr = temp[i];
-    const l = tsplus_module_1.length(arr);
+    for (let i = 1; i < len; i++) {
+      const arr = temp[i];
+      const l = tsplus_module_1.length(arr);
 
-    for (let j = 0; j < l; j++) {
-      out[j + start] = arr._array[j];
-    }
+      for (let j = 0; j < l; j++) {
+        out[j + start] = arr._array[j];
+      }
 
-    start += l;
-  }
+      start += l;
+    }
 
-  return tsplus_module_2.unsafeAsNonEmptyArray(out);
+    return tsplus_module_2.unsafeAsNonEmptyArray(out);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray chop
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray chop
  */
 
 
-function chop_1(self, f) {
-  const [b, rest] = f(self);
-  const result = [b];
-  let next = rest;
+function chop_1(f) {
+  return self => {
+    const [b, rest] = f(self);
+    const result = [b];
+    let next = rest;
 
-  while (tsplus_module_1.isNonEmpty(next)) {
-    const [b, c] = f(next);
-    result.push(b);
-    next = c;
-  }
+    while (tsplus_module_1.isNonEmpty(next)) {
+      const [b, c] = f(next);
+      result.push(b);
+      next = c;
+    }
 
-  return tsplus_module_2.unsafeAsNonEmptyArray(result);
+    return tsplus_module_2.unsafeAsNonEmptyArray(result);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray chunksOf
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray chunksOf
  */
 
 
-function chunksOf_(self, n) {
-  return chop_1(self, as => splitAt_1(as, n));
+function chunksOf(n) {
+  return self => {
+    return chop_1(as => splitAt_1(n)(as))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray concat
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray concat
  */
 
 
-function concat_(self, that) {
-  const leny = tsplus_module_1.length(that);
+function concat(that) {
+  return self => {
+    const leny = tsplus_module_1.length(that);
 
-  if (leny === 0) {
-    return self;
-  }
+    if (leny === 0) {
+      return self;
+    }
 
-  const lenx = tsplus_module_1.length(self);
-  const r = Array(lenx + leny);
+    const lenx = tsplus_module_1.length(self);
+    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.unsafeAsNonEmptyArray(r);
+    return tsplus_module_2.unsafeAsNonEmptyArray(r);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray crossWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray cross
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray cross
  */
 
 
-function cross_(self, fb) {
-  return crossWith_1(self, fb, (a, b) => tsplus_module_5.make(a, b));
+function cross(fb) {
+  return self => {
+    return crossWith_1(fb, (a, b) => tsplus_module_5.make(a, b))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray elem
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray elem
  */
 
 
-function elem_1(self, a,
+function elem_1(a,
 /** @tsplus auto */
 E) {
-  const p = element => E.equals(a, element);
+  return self => {
+    const p = element => E.equals(a, element);
 
-  const len = tsplus_module_1.length(self);
+    const len = tsplus_module_1.length(self);
 
-  for (let i = 0; i < len; i++) {
-    if (p(self._array[i])) {
-      return true;
+    for (let i = 0; i < len; i++) {
+      if (p(self._array[i])) {
+        return true;
+      }
     }
-  }
 
-  return false;
+    return false;
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray flatten
@@ -291,168 +316,194 @@ E) {
 
 
 function flatten(self) {
-  return flatMap_1(self, _function.identity);
+  return flatMap_1(_function.identity)(self);
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray fold
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray fold
  */
 
 
-function fold_(self,
+function fold(
 /** @tsplus auto */
 S) {
-  return tsplus_module_7.foldLeft_(tsplus_module_6.slice_(self, 1), self._array[0], S.combine);
+  return self => {
+    return tsplus_module_7.foldLeft(self._array[0], S.combine)(tsplus_module_6.slice(1)(self));
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldLeft
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray foldLeftWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldLeftWithIndex
  */
 
 
-function foldLeftWithIndex_1(self, b, f) {
-  const len = tsplus_module_1.length(self);
-  let r = b;
+function foldLeftWithIndex_1(b, f) {
+  return self => {
+    const len = tsplus_module_1.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.ImmutableNonEmptyArray foldMapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray foldMap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray foldRight
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray foldRightWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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_1.length(self) - 1; i >= 0; i--) {
-    r = f(i, self._array[i], r);
-  }
+    for (let i = tsplus_module_1.length(self) - 1; i >= 0; i--) {
+      r = f(i, self._array[i], r);
+    }
 
-  return r;
+    return r;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray group
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray group
  */
 
 
-function group_1(self,
+function group_1(
 /** @tsplus auto */
 E) {
-  return chop_1(self, as => {
-    const h = as._array[0];
-    const out = [h];
-    let i = 1;
-
-    for (; i < tsplus_module_1.length(as); i++) {
-      const a = as._array[i];
-
-      if (E.equals(a, h)) {
-        out.push(a);
-      } else {
-        break;
+  return self => {
+    return chop_1(as => {
+      const h = as._array[0];
+      const out = [h];
+      let i = 1;
+
+      for (; i < tsplus_module_1.length(as); i++) {
+        const a = as._array[i];
+
+        if (E.equals(a, h)) {
+          out.push(a);
+        } else {
+          break;
+        }
       }
-    }
 
-    return [tsplus_module_2.unsafeAsNonEmptyArray(out), tsplus_module_6.slice_(as, i)];
-  });
+      return [tsplus_module_2.unsafeAsNonEmptyArray(out), tsplus_module_6.slice(i)(as)];
+    })(self);
+  };
 }
 
 function groupSort(as,
 /** @tsplus auto */
 O) {
-  return group_1(sort_1(as, O), O);
+  return group_1(O)(sort_1(O)(as));
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray isOutOfBound
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray isOutOfBound
  */
 
 
-function isOutOfBound_(as, i) {
-  return i < 0 || i >= tsplus_module_1.length(as);
+function isOutOfBound(i) {
+  return as => {
+    return i < 0 || i >= tsplus_module_1.length(as);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray map
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray 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.ImmutableNonEmptyArray mapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray mapWithIndex
  */
 
 
-function mapWithIndex_1(self, f) {
-  const out = (0, tsplus_module_2.allocWithHead)(f(0, self._array[0]), tsplus_module_1.length(self));
+function mapWithIndex_1(f) {
+  return self => {
+    const out = (0, tsplus_module_2.allocWithHead)(f(0, self._array[0]), tsplus_module_1.length(self));
 
-  for (let i = 1; i < tsplus_module_1.length(self); i++) {
-    out[i] = f(i, self._array[i]);
-  }
+    for (let i = 1; i < tsplus_module_1.length(self); i++) {
+      out[i] = f(i, self._array[i]);
+    }
 
-  return tsplus_module_2.from(out);
+    return tsplus_module_2.from(out);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray max
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray max
  */
 
 
-function max(self,
+function max(
 /** @tsplus auto */
 O) {
-  const S = tsplus_module_8.max(O);
-  const [head, tail] = tsplus_module_3.unprepend(self);
-  return tsplus_module_1.isNonEmpty(tail) ? foldLeft_1(tail, head, S.combine) : head;
+  return self => {
+    const S = tsplus_module_8.max(O);
+    const [head, tail] = tsplus_module_3.unprepend(self);
+    return tsplus_module_1.isNonEmpty(tail) ? foldLeft_1(head, S.combine)(tail) : head;
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray max
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray max
  */
 
 
-function min(self,
+function min(
 /** @tsplus auto */
 O) {
-  const S = tsplus_module_8.min(O);
-  const [head, tail] = tsplus_module_3.unprepend(self);
-  return tsplus_module_1.isNonEmpty(tail) ? foldLeft_1(tail, head, S.combine) : head;
+  return self => {
+    const S = tsplus_module_8.min(O);
+    const [head, tail] = tsplus_module_3.unprepend(self);
+    return tsplus_module_1.isNonEmpty(tail) ? foldLeft_1(head, S.combine)(tail) : head;
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray mutableClone
@@ -463,20 +514,22 @@ function mutableClone(as) {
   return tsplus_module_2.unsafeAsNonEmptyArray(as._array.slice(0));
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray prepend
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray prepend
  */
 
 
-function prepend_(self, head) {
-  const len = tsplus_module_1.length(self);
-  const out = Array(len + 1);
-  out[0] = head;
+function prepend(head) {
+  return self => {
+    const len = tsplus_module_1.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.unsafeAsNonEmptyArray(out);
+    return tsplus_module_2.unsafeAsNonEmptyArray(out);
+  };
 }
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray reverse
@@ -497,78 +550,90 @@ function reverse(self) {
   return tsplus_module_2.from(out);
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray splitAt
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray splitAt
  */
 
 
-function splitAt_1(self, n) {
-  const m = Math.max(1, n);
-  return m >= tsplus_module_1.length(self) ? [self, tsplus_module_9.empty()] : [tsplus_module_2.unsafeAsNonEmptyArray(self._array.slice(0, m)), tsplus_module_6.slice_(self, m)];
+function splitAt_1(n) {
+  return self => {
+    const m = Math.max(1, n);
+    return m >= tsplus_module_1.length(self) ? [self, tsplus_module_9.empty()] : [tsplus_module_2.unsafeAsNonEmptyArray(self._array.slice(0, m)), tsplus_module_6.slice(m)(self)];
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray sort
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray sort
  */
 
 
-function sort_1(self,
+function sort_1(
 /** @tsplus auto */
 O) {
-  return tsplus_module_1.length(self) === 1 ? self : tsplus_module_2.unsafeAsNonEmptyArray(self._array.slice().sort((first, second) => O.compare(first, second)));
+  return self => {
+    return tsplus_module_1.length(self) === 1 ? self : tsplus_module_2.unsafeAsNonEmptyArray(self._array.slice().sort((first, second) => O.compare(first, second)));
+  };
 }
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
- */
 
-
-const traverseWithIndex_1 = /*#__PURE__*/tsplus_module_10.mkTraverseWithIndex_()(() => self => G => f => tsplus_module_7.foldLeftWithIndex_(tsplus_module_3.tail(self), G.map(f(0, tsplus_module_3.head(self)), b => tsplus_module_2.make(b)), (i, fbs, a) => G.zipWith(fbs, f(i + 1, a), (bs, b) => append_1(bs, b))));
-const traverseWithIndex = traverseWithIndex_1;
+function _traverseWithIndex_1(self) {
+  return G => f => tsplus_module_7.foldLeftWithIndex(G.map(b => tsplus_module_2.make(b))(f(0, tsplus_module_3.head(self))), (i, fbs, a) => G.zipWith(f(i + 1, a), (bs, b) => append_1(b)(bs))(fbs))(tsplus_module_3.tail(self));
+}
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  */
 
+
+function _traverse(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 = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray uniq
  */
 
 
 exports.traverse = traverse;
 
-function uniq(self,
+function uniq(
 /** @tsplus auto */
 E) {
-  if (tsplus_module_1.length(self) === 1) {
-    return self;
-  }
+  return self => {
+    if (tsplus_module_1.length(self) === 1) {
+      return self;
+    }
 
-  const out = [self._array[0]];
-  const len = tsplus_module_1.length(self);
+    const out = [self._array[0]];
+    const len = tsplus_module_1.length(self);
 
-  for (let i = 1; i < len; i++) {
-    const a = self._array[i];
+    for (let i = 1; i < len; i++) {
+      const a = self._array[i];
 
-    if (!elem_1(tsplus_module_2.unsafeAsNonEmptyArray(out), a, E)) {
-      out.push(a);
+      if (!elem_1(a, E)(tsplus_module_2.unsafeAsNonEmptyArray(out))) {
+        out.push(a);
+      }
     }
-  }
 
-  return tsplus_module_2.unsafeAsNonEmptyArray(out);
+    return tsplus_module_2.unsafeAsNonEmptyArray(out);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray zipWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray zipWith
  */
 
 
-function zipWith_(self, fb, f) {
-  const len = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
-  const cs = (0, tsplus_module_2.allocWithHead)(f(self._array[0], fb._array[0]), len);
+function zipWith(fb, f) {
+  return self => {
+    const len = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
+    const cs = (0, tsplus_module_2.allocWithHead)(f(self._array[0], fb._array[0]), len);
 
-  for (let i = 1; i < len; i++) {
-    cs[i] = f(self._array[i], fb._array[i]);
-  }
+    for (let i = 1; i < len; i++) {
+      cs[i] = f(self._array[i], fb._array[i]);
+    }
 
-  return tsplus_module_2.from(cs);
+    return tsplus_module_2.from(cs);
+  };
 }
 //# sourceMappingURL=api.cjs.map