@fncts/base 0.0.20 → 0.0.21

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

@@ -7,215 +7,239 @@ import * as tsplus_module_6 from "@fncts/base/collection/immutable/ImmutableArra
 import * as tsplus_module_7 from "@fncts/base/collection/immutable/ImmutableArray/api";
 import * as tsplus_module_8 from "@fncts/base/typeclass/Semigroup/api";
 import * as tsplus_module_9 from "@fncts/base/collection/immutable/ImmutableArray/constructors";
-import * as tsplus_module_10 from "@fncts/base/typeclass/TraversableWithIndex";
-export const append_ = append_1;
-export const alignWith_ = alignWith_1;
-export const flatMap_ = flatMap_1;
-export const flatMapWithIndex_ = flatMapWithIndex_1;
-export const chop_ = chop_1;
-export const crossWith_ = crossWith_1;
-export const elem_ = elem_1;
-export const foldLeft_ = foldLeft_1;
-export const foldLeftWithIndex_ = foldLeftWithIndex_1;
-export const foldMapWithIndex_ = foldMapWithIndex_1;
-export const foldRightWithIndex_ = foldRightWithIndex_1;
+export const append = append_1;
+export const alignWith = alignWith_1;
+export const flatMap = flatMap_1;
+export const flatMapWithIndex = flatMapWithIndex_1;
+export const chop = chop_1;
+export const crossWith = crossWith_1;
+export const elem = elem_1;
+export const foldLeft = foldLeft_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
 export const group = group_1;
-export const map_ = map_1;
-export const mapWithIndex_ = mapWithIndex_1;
-export const splitAt_ = splitAt_1;
+export const map = map_1;
+export const mapWithIndex = mapWithIndex_1;
+export const splitAt = splitAt_1;
 export const sort = sort_1;
+export const _traverseWithIndex = _traverseWithIndex_1;
 import { allocWithHead } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { identity } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray ap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray ap
  */
 
-export function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, a => f(a)));
+export 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
  */
 
 
-export function align_(self, fb) {
-  return alignWith_1(self, fb, identity);
+export function align(fb) {
+  return self => {
+    return alignWith_1(fb, identity)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.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 = 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 = 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 = 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 = 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
  */
 
 
-export function chunksOf_(self, n) {
-  return chop_1(self, as => splitAt_1(as, n));
+export function chunksOf(n) {
+  return self => {
+    return chop_1(as => splitAt_1(n)(as))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray concat
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray concat
  */
 
-export function concat_(self, that) {
-  const leny = tsplus_module_1.length(that);
+export 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
  */
 
 
-export function cross_(self, fb) {
-  return crossWith_1(self, fb, (a, b) => tsplus_module_5.make(a, b));
+export 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
@@ -223,161 +247,187 @@ E) {
 
 
 export function flatten(self) {
-  return flatMap_1(self, identity);
+  return flatMap_1(identity)(self);
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray fold
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray fold
  */
 
-export function fold_(self,
+export 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
  */
 
 
-export function foldMap_(self, f,
+export function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldRight
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldRight
  */
 
-export function foldRight_(self, b, f) {
-  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+export function foldRight(b, f) {
+  return self => {
+    return foldRightWithIndex_1(b, (_, a, b) => f(a, b))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.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);
+  };
 }
 
 export 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
  */
 
-export function isOutOfBound_(as, i) {
-  return i < 0 || i >= tsplus_module_1.length(as);
+export 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 = allocWithHead(f(0, self._array[0]), tsplus_module_1.length(self));
+function mapWithIndex_1(f) {
+  return self => {
+    const out = 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
  */
 
 
-export function max(self,
+export 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
  */
 
-export function min(self,
+export 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
@@ -387,19 +437,21 @@ export function mutableClone(as) {
   return tsplus_module_2.unsafeAsNonEmptyArray(as._array.slice(0));
 }
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray prepend
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray prepend
  */
 
-export function prepend_(self, head) {
-  const len = tsplus_module_1.length(self);
-  const out = Array(len + 1);
-  out[0] = head;
+export 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
@@ -419,71 +471,81 @@ export 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))));
-export 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
  */
 
-export const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+
+export function _traverse(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+export const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
+export const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray uniq
  */
 
-export function uniq(self,
+export 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
  */
 
-export function zipWith_(self, fb, f) {
-  const len = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
-  const cs = allocWithHead(f(self._array[0], fb._array[0]), len);
+export function zipWith(fb, f) {
+  return self => {
+    const len = Math.min(tsplus_module_1.length(self), tsplus_module_1.length(fb));
+    const cs = 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.mjs.map