@fncts/base 0.0.19 → 0.0.21

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

@@ -7,88 +7,94 @@ import * as tsplus_module_6 from "@fncts/base/data/Maybe/constructors";
 import * as tsplus_module_7 from "@fncts/base/internal/Stack";
 import * as tsplus_module_8 from "@fncts/base/data/Either/destructors";
 import * as tsplus_module_9 from "@fncts/base/collection/Iterable/constructors";
-import * as tsplus_module_10 from "@fncts/base/typeclass/TraversableWithIndex";
-import * as tsplus_module_11 from "@fncts/base/data/function/api";
-import * as tsplus_module_12 from "@fncts/base/data/exceptions";
-export const alignWith_ = alignWith_1;
-export const append_ = append_1;
+import * as tsplus_module_10 from "@fncts/base/data/function/api";
+import * as tsplus_module_11 from "@fncts/base/data/exceptions";
+export const alignWith = alignWith_1;
+export const append = append_1;
 export const builder = builder_1;
-export const flatMap_ = flatMap_1;
-export const chop_ = chop_1;
-export const collectWhile_ = collectWhile_1;
-export const concat_ = concat_1;
-export const exists_ = exists_1;
-export const drop_ = drop_1;
-export const filterMap_ = filterMap_1;
-export const filterMapWithIndex_ = filterMapWithIndex_1;
-export const filterWithIndex_ = filterWithIndex_1;
-export const foldLeft_ = foldLeft_1;
-export const foldLeftWithIndex_ = foldLeftWithIndex_1;
-export const foldMapWithIndex_ = foldMapWithIndex_1;
-export const foldRightWithIndex_ = foldRightWithIndex_1;
-export const forEach_ = forEach_1;
-export const mapWithIndex_ = mapWithIndex_1;
+export const flatMap = flatMap_1;
+export const chop = chop_1;
+export const collectWhile = collectWhile_1;
+export const concat = concat_1;
+export const exists = exists_1;
+export const drop = drop_1;
+export const filterMap = filterMap_1;
+export const filterMapWithIndex = filterMapWithIndex_1;
+export const filterWithIndex = filterWithIndex_1;
+export const foldLeft = foldLeft_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
+export const forEach = forEach_1;
+export const mapWithIndex = mapWithIndex_1;
 export const isEmpty = isEmpty_1;
 export const isNonEmpty = isNonEmpty_1;
-export const partitionMap_ = partitionMap_1;
-export const partitionMapWithIndex_ = partitionMapWithIndex_1;
-export const partitionWithIndex_ = partitionWithIndex_1;
-export const splitAt_ = splitAt_1;
-export const take_ = take_1;
-export const unsafeGet_ = unsafeGet_1;
+export const partitionMap = partitionMap_1;
+export const partitionMapWithIndex = partitionMapWithIndex_1;
+export const partitionWithIndex = partitionWithIndex_1;
+export const splitAt = splitAt_1;
+export const take = take_1;
+export const _traverseWithIndex = _traverseWithIndex_1;
+export const _traverse = _traverse_1;
+export const unsafeGet = unsafeGet_1;
 export const unsafeHead = unsafeHead_1;
 export const unsafeTail = unsafeTail_1;
-export const unsafeUpdateAt_ = unsafeUpdateAt_1;
-export const zipWith_ = zipWith_1;
-export const zipWithIndexOffset_ = zipWithIndexOffset_1;
+export const unsafeUpdateAt = unsafeUpdateAt_1;
+export const zipWith = zipWith_1;
+export const zipWithIndexOffset = zipWithIndexOffset_1;
 import { _Empty, BUFFER_SIZE, Chunk, concrete, Singleton, Slice } from "@fncts/base/collection/immutable/Conc/definition";
-import { identity, tuple } from "@fncts/base/data/function";
+import { identity, pipe, tuple } from "@fncts/base/data/function";
 import { Stack } from "@fncts/base/internal/Stack";
-import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.Conc align
+ * @tsplus pipeable fncts.Conc 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.Conc alignWith
+ * @tsplus pipeable fncts.Conc alignWith
  */
 
-function alignWith_1(self, fb, f) {
-  void 0;
-  void 0;
-  const out = builder_1();
-  const minlen = Math.min(self.length, fb.length);
-  const maxlen = Math.max(self.length, fb.length);
-
-  for (let i = 0; i < minlen; i++) {
-    out.append(f(tsplus_module_1.both(self.get(i), fb.get(i))));
-  }
+function alignWith_1(fb, f) {
+  return self => {
+    void 0;
+    void 0;
+    const out = builder_1();
+    const minlen = Math.min(self.length, fb.length);
+    const maxlen = Math.max(self.length, fb.length);
 
-  if (minlen === maxlen) {
-    return out.result();
-  } else if (self.length > fb.length) {
-    for (let i = minlen; i < maxlen; i++) {
-      out.append(f(tsplus_module_1.left(self.get(i))));
+    for (let i = 0; i < minlen; i++) {
+      out.append(f(tsplus_module_1.both(self.get(i), fb.get(i))));
     }
-  } else {
-    for (let i = minlen; i < maxlen; i++) {
-      out.append(f(tsplus_module_1.right(fb.get(i))));
+
+    if (minlen === maxlen) {
+      return out.result();
+    } else if (self.length > fb.length) {
+      for (let i = minlen; i < maxlen; i++) {
+        out.append(f(tsplus_module_1.left(self.get(i))));
+      }
+    } else {
+      for (let i = minlen; i < maxlen; i++) {
+        out.append(f(tsplus_module_1.right(fb.get(i))));
+      }
     }
-  }
 
-  return out.result();
+    return out.result();
+  };
 }
 /**
- * @tsplus fluent fncts.Conc append
+ * @tsplus pipeable fncts.Conc append
  */
 
 
-function append_1(self, a) {
-  void 0;
-  return self.append(a);
+function append_1(a) {
+  return self => {
+    void 0;
+    return self.append(a);
+  };
 }
 
 export class ConcBuilder {
@@ -97,7 +103,7 @@ export class ConcBuilder {
   }
 
   append(a) {
-    this.conc = append_1(this.conc, a);
+    this.conc = append_1(a)(this.conc);
     return this;
   }
 
@@ -114,27 +120,29 @@ function builder_1() {
   return new ConcBuilder(tsplus_module_2.empty());
 }
 /**
- * @tsplus fluent fncts.Conc flatMap
+ * @tsplus pipeable fncts.Conc flatMap
  */
 
 
-function flatMap_1(ma, f) {
-  void 0;
-  const iterator = ma.arrayIterator();
-  let result;
-  let out = tsplus_module_2.empty();
+function flatMap_1(f) {
+  return ma => {
+    void 0;
+    const iterator = ma.arrayIterator();
+    let result;
+    let out = tsplus_module_2.empty();
 
-  while (!(result = iterator.next()).done) {
-    const arr = result.value;
-    const length = arr.length;
+    while (!(result = iterator.next()).done) {
+      const arr = result.value;
+      const length = arr.length;
 
-    for (let i = 0; i < length; i++) {
-      const a = arr[i];
-      out = concat_1(out, f(a));
+      for (let i = 0; i < length; i++) {
+        const a = arr[i];
+        out = concat_1(f(a))(out);
+      }
     }
-  }
 
-  return out;
+    return out;
+  };
 }
 /**
  * @tsplus static fncts.ConcOps chainRecDepthFirst
@@ -153,9 +161,9 @@ export function chainRecDepthFirst(a, f) {
     if (e._tag === "Left"
     /* EitherTag.Left */
     ) {
-      buffer = concat_1(f(e.left), buffer);
+      buffer = concat_1(buffer)(f(e.left));
     } else {
-      out = append_1(out, e.right);
+      out = append_1(e.right)(out);
     }
   }
 
@@ -176,9 +184,9 @@ export function chainRecBreadthFirst(a, f) {
     if (e._tag === "Left"
     /* EitherTag.Left */
     ) {
-      forEach_1(f(e.left), ab => (buffer = append_1(buffer, ab), undefined));
+      forEach_1(ab => (buffer = append_1(ab)(buffer), undefined))(f(e.left));
     } else {
-      out = append_1(out, e.right);
+      out = append_1(e.right)(out);
     }
   }
 
@@ -195,71 +203,77 @@ export function chainRecBreadthFirst(a, f) {
   return out;
 }
 /**
- * @tsplus fluent fncts.Conc chop
+ * @tsplus pipeable fncts.Conc chop
  */
 
-function chop_1(self, f) {
-  const out = builder_1();
-  let cs = self;
+function chop_1(f) {
+  return self => {
+    const out = builder_1();
+    let cs = self;
 
-  while (isNonEmpty_1(cs)) {
-    const [b, c] = f(cs);
-    out.append(b);
-    cs = c;
-  }
+    while (isNonEmpty_1(cs)) {
+      const [b, c] = f(cs);
+      out.append(b);
+      cs = c;
+    }
 
-  return out.result();
+    return out.result();
+  };
 }
 /**
- * @tsplus fluent fncts.Conc chunksOf
+ * @tsplus pipeable fncts.Conc 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);
+  };
 }
 /**
  * Transforms all elements of the Conc for as long as the specified partial function is defined.
  *
- * @tsplus fluent fncts.Conc collectWhile
+ * @tsplus pipeable fncts.Conc collectWhile
  */
 
-function collectWhile_1(as, f) {
-  void 0;
+function collectWhile_1(f) {
+  return as => {
+    void 0;
 
-  switch (as._tag) {
-    case "Singleton"
-    /* ConcTag.Singleton */
-    :
-      {
-        return tsplus_module_4.match_(f(as.value), () => tsplus_module_2.empty(), tsplus_module_3.single);
-      }
+    switch (as._tag) {
+      case "Singleton"
+      /* ConcTag.Singleton */
+      :
+        {
+          return tsplus_module_4.match(() => tsplus_module_2.empty(), tsplus_module_3.single)(f(as.value));
+        }
 
-    case "Chunk"
-    /* ConcTag.Chunk */
-    :
-      {
-        const array = as.arrayLike();
-        let dest = tsplus_module_2.empty();
+      case "Chunk"
+      /* ConcTag.Chunk */
+      :
+        {
+          const array = as.arrayLike();
+          let dest = tsplus_module_2.empty();
 
-        for (let i = 0; i < array.length; i++) {
-          const rhs = f(array[i]);
+          for (let i = 0; i < array.length; i++) {
+            const rhs = f(array[i]);
 
-          if (tsplus_module_5.isJust(rhs)) {
-            dest = append_1(dest, rhs.value);
-          } else {
-            return dest;
+            if (tsplus_module_5.isJust(rhs)) {
+              dest = append_1(rhs.value)(dest);
+            } else {
+              return dest;
+            }
           }
-        }
 
-        return dest;
-      }
+          return dest;
+        }
 
-    default:
-      {
-        return collectWhile_1(as.materialize(), f);
-      }
-  }
+      default:
+        {
+          return collectWhile_1(f)(as.materialize());
+        }
+    }
+  };
 }
 /**
  * @tsplus getter fncts.Conc compact
@@ -267,414 +281,456 @@ function collectWhile_1(as, f) {
 
 
 export function compact(self) {
-  return filterMap_1(self, identity);
+  return filterMap_1(identity)(self);
 }
 /**
- * @tsplus fluent fncts.Conc concat
+ * @tsplus pipeable fncts.Conc concat
  */
 
-function concat_1(self, that) {
-  void 0;
-  void 0;
-  return self.concat(that);
+function concat_1(that) {
+  return self => {
+    void 0;
+    void 0;
+    return self.concat(that);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc elem
+ * @tsplus pipeable fncts.Conc elem
  */
 
 
-export function elem_(self, a,
+export function elem(a,
 /** @tsplus auto */
 E) {
-  return exists_1(self, el => E.equals(el, a));
+  return self => {
+    return exists_1(el => E.equals(el, a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc exists
+ * @tsplus pipeable fncts.Conc exists
  */
 
-function exists_1(as, predicate) {
-  void 0;
-  const iterator = as.arrayIterator();
-  let exists = false;
-  let result;
+function exists_1(predicate) {
+  return as => {
+    void 0;
+    const iterator = as.arrayIterator();
+    let exists = false;
+    let result;
 
-  while (!exists && !(result = iterator.next()).done) {
-    const array = result.value;
+    while (!exists && !(result = iterator.next()).done) {
+      const array = result.value;
 
-    for (let i = 0; !exists && i < array.length; i++) {
-      exists = predicate(array[i]);
+      for (let i = 0; !exists && i < array.length; i++) {
+        exists = predicate(array[i]);
+      }
     }
-  }
 
-  return exists;
+    return exists;
+  };
 }
 /**
- * @tsplus fluent fncts.Conc drop
+ * @tsplus pipeable fncts.Conc drop
  */
 
 
-function drop_1(self, n) {
-  void 0;
-  const len = self.length;
+function drop_1(n) {
+  return self => {
+    void 0;
+    const len = self.length;
 
-  if (len <= 0) {
-    return self;
-  } else if (n >= len) {
-    return tsplus_module_2.empty();
-  } else {
-    switch (self._tag) {
-      case "Slice"
-      /* ConcTag.Slice */
-      :
-        return new Slice(self.conc, self.offset + n, self.l - n);
+    if (len <= 0) {
+      return self;
+    } else if (n >= len) {
+      return tsplus_module_2.empty();
+    } else {
+      switch (self._tag) {
+        case "Slice"
+        /* ConcTag.Slice */
+        :
+          return new Slice(self.conc, self.offset + n, self.l - n);
 
-      case "Singleton"
-      /* ConcTag.Singleton */
-      :
-        return n > 0 ? tsplus_module_2.empty() : self;
+        case "Singleton"
+        /* ConcTag.Singleton */
+        :
+          return n > 0 ? tsplus_module_2.empty() : self;
 
-      case "Empty"
-      /* ConcTag.Empty */
-      :
-        return tsplus_module_2.empty();
+        case "Empty"
+        /* ConcTag.Empty */
+        :
+          return tsplus_module_2.empty();
 
-      default:
-        return new Slice(self, n, len - n);
+        default:
+          return new Slice(self, n, len - n);
+      }
     }
-  }
+  };
 }
 /**
- * @tsplus fluent fncts.Conc dropUntil
+ * @tsplus pipeable fncts.Conc dropUntil
  */
 
 
-export function dropUntil(self, p) {
-  let cont = true;
-  let i = 0;
+export function dropUntil(p) {
+  return self => {
+    let cont = true;
+    let i = 0;
 
-  for (const elem of self) {
-    if (!cont) {
-      break;
-    }
+    for (const elem of self) {
+      if (!cont) {
+        break;
+      }
 
-    i++;
-    cont = !p(elem);
-  }
+      i++;
+      cont = !p(elem);
+    }
 
-  return drop_1(self, i);
+    return drop_1(i)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc dropWhile
+ * @tsplus pipeable fncts.Conc dropWhile
  */
 
-export function dropWhile_(self, p) {
-  void 0;
-
-  switch (self._tag) {
-    case "Chunk"
-    /* ConcTag.Chunk */
-    :
-      {
-        const arr = self.arrayLike();
-        let i = 0;
-
-        while (i < arr.length && p(arr[i])) {
-          i++;
-        }
+export function dropWhile(p) {
+  return self => {
+    void 0;
 
-        return drop_1(self, i);
-      }
+    switch (self._tag) {
+      case "Chunk"
+      /* ConcTag.Chunk */
+      :
+        {
+          const arr = self.arrayLike();
+          let i = 0;
 
-    default:
-      {
-        const iterator = self.arrayIterator();
-        let result;
-        let cont = true;
-        let i = 0;
+          while (i < arr.length && p(arr[i])) {
+            i++;
+          }
 
-        while (cont && !(result = iterator.next()).done) {
-          const array = result.value;
-          let j = 0;
+          return drop_1(i)(self);
+        }
 
-          while (cont && j < array.length) {
-            if (p(array[j])) {
-              i++;
-              j++;
-            } else {
-              cont = false;
+      default:
+        {
+          const iterator = self.arrayIterator();
+          let result;
+          let cont = true;
+          let i = 0;
+
+          while (cont && !(result = iterator.next()).done) {
+            const array = result.value;
+            let j = 0;
+
+            while (cont && j < array.length) {
+              if (p(array[j])) {
+                i++;
+                j++;
+              } else {
+                cont = false;
+              }
             }
           }
-        }
 
-        return drop_1(self, i);
-      }
-  }
+          return drop_1(i)(self);
+        }
+    }
+  };
 }
-export function filter_(self, p) {
-  return filterWithIndex_1(self, (_, a) => p(a));
+export function filter(p) {
+  return self => {
+    return filterWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc filterMap
+ * @tsplus pipeable fncts.Conc filterMap
  */
 
-function filterMap_1(self, f) {
-  return filterMapWithIndex_1(self, (_, a) => f(a));
+function filterMap_1(f) {
+  return self => {
+    return filterMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc filterMapWithIndex
+ * @tsplus pipeable fncts.Conc filterMapWithIndex
  */
 
 
-function filterMapWithIndex_1(self, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  const out = builder_1();
-  let result;
-  let i = 0;
+function filterMapWithIndex_1(f) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    const out = builder_1();
+    let result;
+    let i = 0;
 
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
 
-    for (let j = 0; j < array.length; j++) {
-      const ob = f(i, array[j]);
+      for (let j = 0; j < array.length; j++) {
+        const ob = f(i, array[j]);
 
-      if (tsplus_module_5.isJust(ob)) {
-        out.append(ob.value);
-      }
+        if (tsplus_module_5.isJust(ob)) {
+          out.append(ob.value);
+        }
 
-      i++;
+        i++;
+      }
     }
-  }
 
-  return out.result();
+    return out.result();
+  };
 }
 
-function filterWithIndex_1(self, p) {
-  void 0;
+function filterWithIndex_1(p) {
+  return self => {
+    void 0;
 
-  switch (self._tag) {
-    case "Empty"
-    /* ConcTag.Empty */
-    :
-      {
-        return _Empty;
-      }
+    switch (self._tag) {
+      case "Empty"
+      /* ConcTag.Empty */
+      :
+        {
+          return _Empty;
+        }
 
-    case "Chunk"
-    /* ConcTag.Chunk */
-    :
-      {
-        const arr = self.arrayLike();
-        let builder = tsplus_module_2.empty();
+      case "Chunk"
+      /* ConcTag.Chunk */
+      :
+        {
+          const arr = self.arrayLike();
+          let builder = tsplus_module_2.empty();
 
-        for (let i = 0; i < arr.length; i++) {
-          const a = arr[i];
+          for (let i = 0; i < arr.length; i++) {
+            const a = arr[i];
 
-          if (p(i, a)) {
-            builder = append_1(builder, a);
+            if (p(i, a)) {
+              builder = append_1(a)(builder);
+            }
           }
+
+          return builder;
         }
 
-        return builder;
-      }
+      case "Singleton"
+      /* ConcTag.Singleton */
+      :
+        {
+          if (p(0, self.value)) {
+            return self;
+          }
 
-    case "Singleton"
-    /* ConcTag.Singleton */
-    :
-      {
-        if (p(0, self.value)) {
-          return self;
+          return _Empty;
         }
 
-        return _Empty;
-      }
+      default:
+        {
+          const iterator = self.arrayIterator();
+          let out = tsplus_module_2.empty();
+          let result;
+          let i = 0;
 
-    default:
-      {
-        const iterator = self.arrayIterator();
-        let out = tsplus_module_2.empty();
-        let result;
-        let i = 0;
+          while (!(result = iterator.next()).done) {
+            const array = result.value;
 
-        while (!(result = iterator.next()).done) {
-          const array = result.value;
+            for (let j = 0; j < array.length; j++) {
+              const a = array[j];
 
-          for (let j = 0; j < array.length; j++) {
-            const a = array[j];
+              if (p(i, a)) {
+                out = append_1(a)(out);
+              }
 
-            if (p(i, a)) {
-              out = append_1(out, a);
+              i++;
             }
-
-            i++;
           }
-        }
 
-        return out;
-      }
-  }
+          return out;
+        }
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.Conc find
+ * @tsplus pipeable fncts.Conc find
  */
 
 
-export function find_(self, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  let out = tsplus_module_6.nothing();
-  let result;
+export function find(f) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    let out = tsplus_module_6.nothing();
+    let result;
 
-  while (tsplus_module_5.isNothing(out) && !(result = iterator.next()).done) {
-    const array = result.value;
-    const length = array.length;
+    while (tsplus_module_5.isNothing(out) && !(result = iterator.next()).done) {
+      const array = result.value;
+      const length = array.length;
 
-    for (let i = 0; tsplus_module_5.isNothing(out) && i < length; i++) {
-      const a = array[i];
+      for (let i = 0; tsplus_module_5.isNothing(out) && i < length; i++) {
+        const a = array[i];
 
-      if (f(a)) {
-        out = tsplus_module_6.just(a);
+        if (f(a)) {
+          out = tsplus_module_6.just(a);
+        }
       }
     }
-  }
 
-  return out;
+    return out;
+  };
 }
 /**
  * @tsplus getter fncts.Conc flatten
  */
 
 export function flatten(self) {
-  return flatMap_1(self, identity);
+  return flatMap_1(identity)(self);
 }
 /**
  * Folds over the elements in this Conc from the left.
  * Stops the fold early when the condition is not fulfilled.
  *
- * @tsplus fluent fncts.Conc foldLeftWhile
+ * @tsplus pipeable fncts.Conc foldLeftWhile
  */
 
-export function foldLeftWhile_(as, b, p, f) {
-  void 0;
-  const iterator = as.arrayIterator();
-  let s = b;
-  let cont = p(s);
-  let result;
+export function foldLeftWhile(b, p, f) {
+  return as => {
+    void 0;
+    const iterator = as.arrayIterator();
+    let s = b;
+    let cont = p(s);
+    let result;
 
-  while (cont && !(result = iterator.next()).done) {
-    const array = result.value;
+    while (cont && !(result = iterator.next()).done) {
+      const array = result.value;
 
-    for (let i = 0; cont && i < array.length; i++) {
-      s = f(s, array[i]);
-      cont = p(s);
+      for (let i = 0; cont && i < array.length; i++) {
+        s = f(s, array[i]);
+        cont = p(s);
+      }
     }
-  }
 
-  return s;
+    return s;
+  };
 }
 /**
- * @tsplus fluent fncts.Conc foldLeft
+ * @tsplus pipeable fncts.Conc 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.Conc foldLeftWithIndex
+ * @tsplus pipeable fncts.Conc foldLeftWithIndex
  */
 
 
-function foldLeftWithIndex_1(self, b, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  let out = b;
-  let result;
-  let i = 0;
+function foldLeftWithIndex_1(b, f) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    let out = b;
+    let result;
+    let i = 0;
 
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
 
-    for (let j = 0; j < array.length; j++) {
-      out = f(i, out, array[j]);
-      i++;
+      for (let j = 0; j < array.length; j++) {
+        out = f(i, out, array[j]);
+        i++;
+      }
     }
-  }
 
-  return out;
+    return out;
+  };
 }
 /**
- * @tsplus fluent fncts.Conc foldMap
+ * @tsplus pipeable fncts.Conc foldMap
  */
 
 
-export function foldMap_(fa, f,
+export function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(fa, (_, a) => f(a), M);
+  return fa => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc foldMapWithIndex
+ * @tsplus pipeable fncts.Conc foldMapWithIndex
  */
 
-function foldMapWithIndex_1(fa, f,
+function foldMapWithIndex_1(f,
 /** @tsplus auto */
 M) {
-  return foldLeftWithIndex_1(fa, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+  return fa => {
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(b, f(i, a)))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc foldRight
+ * @tsplus pipeable fncts.Conc foldRight
  */
 
 
-export function foldRight_(fa, b, f) {
-  return foldRightWithIndex_1(fa, b, (_, a, b) => f(a, b));
+export function foldRight(b, f) {
+  return fa => {
+    return foldRightWithIndex_1(b, (_, a, b) => f(a, b))(fa);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc foldRightWithIndex
+ * @tsplus pipeable fncts.Conc foldRightWithIndex
  */
 
-function foldRightWithIndex_1(self, b, f) {
-  void 0;
-  const iterator = self.reverseArrayIterator();
-  let out = b;
-  let result;
-  let i = self.length - 1;
+function foldRightWithIndex_1(b, f) {
+  return self => {
+    void 0;
+    const iterator = self.reverseArrayIterator();
+    let out = b;
+    let result;
+    let i = self.length - 1;
 
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
 
-    for (let j = array.length - 1; j >= 0; j--) {
-      out = f(i, array[i], out);
-      i--;
+      for (let j = array.length - 1; j >= 0; j--) {
+        out = f(i, array[i], out);
+        i--;
+      }
     }
-  }
 
-  return out;
+    return out;
+  };
 }
 /**
- * @tsplus fluent fncts.Conc forEach
+ * @tsplus pipeable fncts.Conc forEach
  */
 
 
-function forEach_1(self, f) {
-  void 0;
-  return self.forEach(0, (_, a) => f(a));
+function forEach_1(f) {
+  return self => {
+    void 0;
+    return self.forEach(0, (_, a) => f(a));
+  };
 }
 /**
- * @tsplus fluent fncts.Conc forEachWithIndex
+ * @tsplus pipeable fncts.Conc forEachWithIndex
  */
 
 
-export function forEachWithIndex_(self, f) {
-  void 0;
-  self.forEach(0, f);
+export function forEachWithIndex(f) {
+  return self => {
+    void 0;
+    self.forEach(0, f);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc get
+ * @tsplus pipeable fncts.Conc get
  */
 
-export function get_(as, n) {
-  return tsplus_module_6.tryCatch(() => unsafeGet_1(as, n));
+export function get(n) {
+  return as => {
+    return tsplus_module_6.tryCatch(() => unsafeGet_1(n)(as));
+  };
 }
 /**
  * @tsplus getter fncts.Conc head
@@ -698,18 +754,20 @@ export function init(self) {
     return tsplus_module_6.nothing();
   }
 
-  return tsplus_module_6.just(take_1(self, self.length - 1));
+  return tsplus_module_6.just(take_1(self.length - 1)(self));
 }
 /**
- * @tsplus fluent fncts.Conc join
+ * @tsplus pipeable fncts.Conc join
  */
 
-export function join_(self, separator) {
-  if (self.length === 0) {
-    return "";
-  }
+export function join(separator) {
+  return self => {
+    if (self.length === 0) {
+      return "";
+    }
 
-  return foldLeft_1(unsafeTail_1(self), unsafeGet_1(self, 0), (b, s) => b + separator + s);
+    return foldLeft_1(unsafeGet_1(0)(self), (b, s) => b + separator + s)(unsafeTail_1(self));
+  };
 }
 /**
  * @tsplus getter fncts.Conc last
@@ -725,45 +783,49 @@ export function last(self) {
   return tsplus_module_6.just(self.get(self.length - 1));
 }
 /**
- * @tsplus fluent fncts.Conc map
+ * @tsplus pipeable fncts.Conc map
  */
 
-export function map_(self, f) {
-  return mapWithIndex_1(self, (_, a) => f(a));
+export function map(f) {
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
  * Statefully maps over the Conc, producing new elements of type `B`.
  *
- * @tsplus fluent fncts.Conc mapAccum
+ * @tsplus pipeable fncts.Conc mapAccum
  */
 
-export function mapAccum_(self, s, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  const out = builder_1();
-  let state = s;
-  let result;
-
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
-    const length = array.length;
-
-    for (let i = 0; i < length; i++) {
-      const a = array[i];
-      const tup = f(state, a);
-      out.append(tup[1]);
-      state = tup[0];
+export function mapAccum(s, f) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    const out = builder_1();
+    let state = s;
+    let result;
+
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
+      const length = array.length;
+
+      for (let i = 0; i < length; i++) {
+        const a = array[i];
+        const tup = f(state, a);
+        out.append(tup[1]);
+        state = tup[0];
+      }
     }
-  }
 
-  return tuple(s, out.result());
+    return tuple(s, out.result());
+  };
 }
 
 function mapArrayLike(as, len, startIndex, f) {
   let bs = tsplus_module_2.empty();
 
   for (let i = 0; i < len; i++) {
-    bs = append_1(bs, f(i + startIndex, as[i]));
+    bs = append_1(f(i + startIndex, as[i]))(bs);
   }
 
   return bs;
@@ -773,7 +835,7 @@ function mapArrayLikeReverse(as, len, endIndex, f) {
   let bs = tsplus_module_2.empty();
 
   for (let i = BUFFER_SIZE - len, j = len - 1; i < BUFFER_SIZE; i++, j--) {
-    bs = append_1(bs, f(endIndex - j, as[i]));
+    bs = append_1(f(endIndex - j, as[i]))(bs);
   }
 
   return bs;
@@ -822,132 +884,134 @@ class PrependFrame {
 
 }
 /**
- * @tsplus fluent fncts.Conc mapWithIndex
+ * @tsplus pipeable fncts.Conc mapWithIndex
  */
 
 
-function mapWithIndex_1(self, f) {
-  let current = self;
-  let index = 0;
-  const stack = tsplus_module_7.mkStack();
-  stack.push(new DoneFrame());
-  let result = tsplus_module_2.empty();
-
-  recursion: while (stack.hasNext) {
-    // eslint-disable-next-line no-constant-condition
-    pushing: while (true) {
-      void 0;
+function mapWithIndex_1(f) {
+  return self => {
+    let current = self;
+    let index = 0;
+    const stack = tsplus_module_7.makeStack();
+    stack.push(new DoneFrame());
+    let result = tsplus_module_2.empty();
+
+    recursion: while (stack.hasNext) {
+      // eslint-disable-next-line no-constant-condition
+      pushing: while (true) {
+        void 0;
+
+        switch (current._tag) {
+          case "Singleton"
+          /* ConcTag.Singleton */
+          :
+            {
+              result = new Singleton(f(index++, current.value));
+              break pushing;
+            }
 
-      switch (current._tag) {
-        case "Singleton"
-        /* ConcTag.Singleton */
-        :
-          {
-            result = new Singleton(f(index++, current.value));
-            break pushing;
-          }
+          case "Empty"
+          /* ConcTag.Empty */
+          :
+            {
+              result = _Empty;
+              break pushing;
+            }
 
-        case "Empty"
-        /* ConcTag.Empty */
-        :
-          {
-            result = _Empty;
-            break pushing;
-          }
+          case "Chunk"
+          /* ConcTag.Chunk */
+          :
+            {
+              result = new Chunk(current._array.map((a, i) => f(i + index, a)));
+              index += current.length;
+              break pushing;
+            }
 
-        case "Chunk"
-        /* ConcTag.Chunk */
-        :
-          {
-            result = new Chunk(current._array.map((a, i) => f(i + index, a)));
-            index += current.length;
-            break pushing;
-          }
+          case "Concat"
+          /* ConcTag.Concat */
+          :
+            {
+              stack.push(new ConcatLeftFrame(current, index));
+              current = current.left;
+              continue pushing;
+            }
 
-        case "Concat"
-        /* ConcTag.Concat */
-        :
-          {
-            stack.push(new ConcatLeftFrame(current, index));
-            current = current.left;
-            continue pushing;
-          }
+          case "AppendN"
+          /* ConcTag.AppendN */
+          :
+            {
+              stack.push(new AppendFrame(current.buffer, current.bufferUsed, index));
+              current = current.start;
+              continue pushing;
+            }
 
-        case "AppendN"
-        /* ConcTag.AppendN */
-        :
-          {
-            stack.push(new AppendFrame(current.buffer, current.bufferUsed, index));
-            current = current.start;
-            continue pushing;
-          }
+          case "PrependN"
+          /* ConcTag.PrependN */
+          :
+            {
+              stack.push(new PrependFrame(mapArrayLikeReverse(current.buffer, current.bufferUsed, index + current.bufferUsed - 1, f), current.end));
+              index += current.bufferUsed;
+              break pushing;
+            }
 
-        case "PrependN"
-        /* ConcTag.PrependN */
-        :
-          {
-            stack.push(new PrependFrame(mapArrayLikeReverse(current.buffer, current.bufferUsed, index + current.bufferUsed - 1, f), current.end));
-            index += current.bufferUsed;
-            break pushing;
-          }
+          case "Slice"
+          /* ConcTag.Slice */
+          :
+            {
+              let r = tsplus_module_2.empty();
 
-        case "Slice"
-        /* ConcTag.Slice */
-        :
-          {
-            let r = tsplus_module_2.empty();
+              for (let i = 0; i < current.length; i++) {
+                r = append_1(f(i + index, current[i]))(r);
+              }
 
-            for (let i = 0; i < current.length; i++) {
-              r = append_1(r, f(i + index, unsafeGet_1(current, i)));
+              result = r;
+              index += current.length;
+              break pushing;
             }
-
-            result = r;
-            index += current.length;
-            break pushing;
-          }
-      }
-    } // eslint-disable-next-line no-constant-condition
+        }
+      } // eslint-disable-next-line no-constant-condition
 
 
-    popping: while (true) {
-      const top = stack.pop();
+      popping: while (true) {
+        const top = stack.pop();
 
-      switch (top._tag) {
-        case "Done":
-          {
-            return result;
-          }
+        switch (top._tag) {
+          case "Done":
+            {
+              return result;
+            }
 
-        case "ConcatLeft":
-          {
-            current = top.conc.right;
-            stack.push(new ConcatRightFrame(result));
-            continue recursion;
-          }
+          case "ConcatLeft":
+            {
+              current = top.conc.right;
+              stack.push(new ConcatRightFrame(result));
+              continue recursion;
+            }
 
-        case "ConcatRight":
-          {
-            result = concat_1(top.leftResult, result);
-            continue popping;
-          }
+          case "ConcatRight":
+            {
+              result = concat_1(result)(top.leftResult);
+              continue popping;
+            }
 
-        case "Append":
-          {
-            result = concat_1(result, mapArrayLike(top.buffer, top.bufferUsed, index, f));
-            continue popping;
-          }
+          case "Append":
+            {
+              result = concat_1(mapArrayLike(top.buffer, top.bufferUsed, index, f))(result);
+              continue popping;
+            }
 
-        case "Prepend":
-          {
-            current = top.end;
-            stack.push(new ConcatRightFrame(top.pre));
-            continue recursion;
-          }
+          case "Prepend":
+            {
+              current = top.end;
+              stack.push(new ConcatRightFrame(top.pre));
+              continue recursion;
+            }
+        }
       }
     }
-  }
 
-  throw new Error("bug");
+    throw new Error("bug");
+  };
 }
 /**
  * @tsplus getter fncts.Conc isEmpty
@@ -967,76 +1031,86 @@ function isNonEmpty_1(conc) {
   return !isEmpty_1(conc);
 }
 
-export function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+export function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc partitionMap
+ * @tsplus pipeable fncts.Conc partitionMap
  */
 
-function partitionMap_1(self, f) {
-  return partitionMapWithIndex_1(self, (_, a) => f(a));
+function partitionMap_1(f) {
+  return self => {
+    return partitionMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc partitionMapWithIndex
+ * @tsplus pipeable fncts.Conc partitionMapWithIndex
  */
 
 
-function partitionMapWithIndex_1(fa, f) {
-  void 0;
-  const iterator = fa.arrayIterator();
-  const left = builder_1();
-  const right = builder_1();
-  let result;
-  let i = 0;
-
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
-
-    for (let j = 0; j < array.length; j++) {
-      const eab = f(i, array[j]);
-      tsplus_module_8.match_(eab, b => left.append(b), c => right.append(c));
-      i++;
+function partitionMapWithIndex_1(f) {
+  return fa => {
+    void 0;
+    const iterator = fa.arrayIterator();
+    const left = builder_1();
+    const right = builder_1();
+    let result;
+    let i = 0;
+
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
+
+      for (let j = 0; j < array.length; j++) {
+        const eab = f(i, array[j]);
+        tsplus_module_8.match(b => left.append(b), c => right.append(c))(eab);
+        i++;
+      }
     }
-  }
 
-  return [left.result(), right.result()];
+    return [left.result(), right.result()];
+  };
 }
 
-function partitionWithIndex_1(self, p) {
-  void 0;
-  const iterator = self.arrayIterator();
-  const left = builder_1();
-  const right = builder_1();
-  let result;
-  let i = 0;
-
-  while (!(result = iterator.next()).done) {
-    const array = result.value;
-
-    for (let j = 0; j < array.length; j++) {
-      const a = array[j];
-
-      if (p(i, a)) {
-        right.append(a);
-      } else {
-        left.append(a);
-      }
+function partitionWithIndex_1(p) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    const left = builder_1();
+    const right = builder_1();
+    let result;
+    let i = 0;
 
-      i++;
+    while (!(result = iterator.next()).done) {
+      const array = result.value;
+
+      for (let j = 0; j < array.length; j++) {
+        const a = array[j];
+
+        if (p(i, a)) {
+          right.append(a);
+        } else {
+          left.append(a);
+        }
+
+        i++;
+      }
     }
-  }
 
-  return [left.result(), right.result()];
+    return [left.result(), right.result()];
+  };
 }
 /**
- * @tsplus fluent fncts.Conc prepend
+ * @tsplus pipeable fncts.Conc prepend
  */
 
 
-export function prepend_(self, a) {
-  void 0;
-  return self.prepend(a);
+export function prepend(a) {
+  return self => {
+    void 0;
+    return self.prepend(a);
+  };
 }
 /**
  * @tsplus getter fncts.Conc reverse
@@ -1045,7 +1119,7 @@ export function prepend_(self, a) {
 export function reverse(self) {
   void 0;
   const arr = self.arrayLike();
-  return tsplus_module_9.mkIterable(() => {
+  return tsplus_module_9.makeIterable(() => {
     let i = arr.length - 1;
     return {
       next: () => {
@@ -1071,47 +1145,51 @@ export function reverse(self) {
  */
 
 export function separate(self) {
-  return partitionMap_1(self, identity);
+  return partitionMap_1(identity)(self);
 }
 /**
- * @tsplus fluent fncts.Conc splitAt
+ * @tsplus pipeable fncts.Conc splitAt
  */
 
-function splitAt_1(self, n) {
-  return [take_1(self, n), drop_1(self, n)];
+function splitAt_1(n) {
+  return self => {
+    return [take_1(n)(self), drop_1(n)(self)];
+  };
 }
 /**
  * Splits this Conc on the first element that matches this predicate.
  *
- * @tsplus fluent fncts.Conc splitWhere
+ * @tsplus pipeable fncts.Conc splitWhere
  */
 
 
-export function splitWhere_(self, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  let next;
-  let cont = true;
-  let i = 0;
-
-  while (cont && (next = iterator.next()) && !next.done) {
-    const array = next.value;
-    const len = array.length;
-    let j = 0;
-
-    while (cont && j < len) {
-      const a = array[j];
-
-      if (f(a)) {
-        cont = false;
-      } else {
-        i++;
-        j++;
+export function splitWhere(f) {
+  return self => {
+    void 0;
+    const iterator = self.arrayIterator();
+    let next;
+    let cont = true;
+    let i = 0;
+
+    while (cont && (next = iterator.next()) && !next.done) {
+      const array = next.value;
+      const len = array.length;
+      let j = 0;
+
+      while (cont && j < len) {
+        const a = array[j];
+
+        if (f(a)) {
+          cont = false;
+        } else {
+          i++;
+          j++;
+        }
       }
     }
-  }
 
-  return splitAt_1(self, i);
+    return splitAt_1(i)(self);
+  };
 }
 /**
  * @tsplus getter fncts.Conc tail
@@ -1122,85 +1200,93 @@ export function tail(conc) {
     return tsplus_module_6.nothing();
   }
 
-  return tsplus_module_6.just(drop_1(conc, 1));
+  return tsplus_module_6.just(drop_1(1)(conc));
 }
 /**
- * @tsplus fluent fncts.Conc take
+ * @tsplus pipeable fncts.Conc take
  */
 
-function take_1(self, n) {
-  void 0;
-  return self.take(n);
+function take_1(n) {
+  return self => {
+    void 0;
+    return self.take(n);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc takeWhile
+ * @tsplus pipeable fncts.Conc takeWhile
  */
 
 
-export function takeWhile_(self, p) {
-  void 0;
-
-  switch (self._tag) {
-    case "Chunk"
-    /* ConcTag.Chunk */
-    :
-      {
-        const arr = self.arrayLike();
-        let i = 0;
-
-        while (i < arr.length && p(arr[i])) {
-          i++;
-        }
+export function takeWhile(p) {
+  return self => {
+    void 0;
 
-        return take_1(self, i);
-      }
+    switch (self._tag) {
+      case "Chunk"
+      /* ConcTag.Chunk */
+      :
+        {
+          const arr = self.arrayLike();
+          let i = 0;
 
-    default:
-      {
-        const iterator = self.arrayIterator();
-        let result;
-        let cont = true;
-        let i = 0;
+          while (i < arr.length && p(arr[i])) {
+            i++;
+          }
 
-        while (cont && !(result = iterator.next()).done) {
-          const array = result.value;
-          let j = 0;
+          return self.take(i);
+        }
 
-          while (cont && j < array.length) {
-            if (!p(array[j])) {
-              cont = false;
-            } else {
-              i++;
-              j++;
+      default:
+        {
+          const iterator = self.arrayIterator();
+          let result;
+          let cont = true;
+          let i = 0;
+
+          while (cont && !(result = iterator.next()).done) {
+            const array = result.value;
+            let j = 0;
+
+            while (cont && j < array.length) {
+              if (!p(array[j])) {
+                cont = false;
+              } else {
+                i++;
+                j++;
+              }
             }
           }
+
+          return self.take(i);
         }
+    }
+  };
+}
+export const traverse = G => f => self => _traverse_1(self)(G)(f);
+export const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
 
-        return take_1(self, i);
-      }
-  }
+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.Conc traverse
  */
 
-export const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
-/**
- * @tsplus getter fncts.Conc traverseWithIndex
- */
 
-const traverseWithIndex_1 = /*#__PURE__*/tsplus_module_10.mkTraverseWithIndex_()(() => self => G => f => foldLeftWithIndex_1(self, G.pure(tsplus_module_2.empty()), (i, fbs, a) => G.zipWith(fbs, f(i, a), (bs, b) => append_1(bs, b))));
-export const traverseWithIndex = traverseWithIndex_1;
+function _traverse_1(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
 /**
  * @tsplus getter fncts.Conc toBuffer
  */
 
+
 export function toBuffer(self) {
   void 0;
   return self.arrayLike();
 }
 /**
- * @tsplus fluent fncts.ConcOps unfold
+ * @tsplus static fncts.ConcOps unfold
  */
 
 export function unfold(b, f) {
@@ -1220,13 +1306,15 @@ export function unfold(b, f) {
   }
 }
 /**
- * @tsplus fluent fncts.Conc unsafeGet
- * @tsplus index fncts.Conc
+ * @tsplus pipeable fncts.Conc unsafeGet
+ * @tsplus pipeable-index fncts.Conc
  */
 
-function unsafeGet_1(self, n) {
-  void 0;
-  return self.get(n);
+function unsafeGet_1(n) {
+  return self => {
+    void 0;
+    return self.get(n);
+  };
 }
 /**
  * Returns the first element of this Conc. Note that this method is partial
@@ -1254,82 +1342,90 @@ function unsafeHead_1(as) {
 
 function unsafeTail_1(self) {
   if (self.length === 0) {
-    throw new tsplus_module_12.ArrayIndexOutOfBoundsError("Chunk.unsafeTail access to 1");
+    throw new tsplus_module_11.ArrayIndexOutOfBoundsError("Chunk.unsafeTail access to 1");
   }
 
-  return drop_1(self, 1);
+  return drop_1(1)(self);
 }
 /**
- * @tsplus fluent fncts.Conc unsafeUpdateAt
+ * @tsplus pipeable fncts.Conc unsafeUpdateAt
  */
 
 
-function unsafeUpdateAt_1(self, i, a) {
-  void 0;
-  return self.update(i, a);
+function unsafeUpdateAt_1(i, a) {
+  return self => {
+    void 0;
+    return self.update(i, a);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc updateAt
+ * @tsplus pipeable fncts.Conc updateAt
  */
 
 
-export function updateAt_(self, i, a) {
-  try {
-    return tsplus_module_6.just(unsafeUpdateAt_1(self, i, a));
-  } catch {
-    return tsplus_module_6.nothing();
-  }
+export function updateAt(i, a) {
+  return self => {
+    try {
+      return tsplus_module_6.just(unsafeUpdateAt_1(i, a)(self));
+    } catch {
+      return tsplus_module_6.nothing();
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.Conc zip
+ * @tsplus pipeable fncts.Conc zip
  */
 
-export function zip_(self, fb) {
-  return zipWith_1(self, fb, tuple);
+export function zip(fb) {
+  return self => {
+    return zipWith_1(fb, tuple)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc zipWith
+ * @tsplus pipeable fncts.Conc zipWith
  */
 
-function zipWith_1(self, fb, f) {
-  void 0;
-  void 0;
-  const length = Math.min(self.length, fb.length);
+function zipWith_1(fb, f) {
+  return self => {
+    void 0;
+    void 0;
+    const length = Math.min(self.length, fb.length);
 
-  if (length === 0) {
-    return tsplus_module_2.empty();
-  } else {
-    const leftIterator = self.arrayIterator();
-    const rightIterator = fb.arrayIterator();
-    const out = builder_1();
-    let left = null;
-    let right = null;
-    let leftLength = 0;
-    let rightLength = 0;
-    let i = 0;
-    let j = 0;
-    let k = 0;
-
-    while (i < length) {
-      if (j < leftLength && k < rightLength) {
-        const a = left.value[j];
-        const b = right.value[k];
-        const c = f(a, b);
-        out.append(c);
-        i++;
-        j++;
-        k++;
-      } else if (j === leftLength && !(left = leftIterator.next()).done) {
-        leftLength = left.value.length;
-        j = 0;
-      } else if (k === rightLength && !(right = rightIterator.next()).done) {
-        rightLength = right.value.length;
-        k = 0;
+    if (length === 0) {
+      return tsplus_module_2.empty();
+    } else {
+      const leftIterator = self.arrayIterator();
+      const rightIterator = fb.arrayIterator();
+      const out = builder_1();
+      let left = null;
+      let right = null;
+      let leftLength = 0;
+      let rightLength = 0;
+      let i = 0;
+      let j = 0;
+      let k = 0;
+
+      while (i < length) {
+        if (j < leftLength && k < rightLength) {
+          const a = left.value[j];
+          const b = right.value[k];
+          const c = f(a, b);
+          out.append(c);
+          i++;
+          j++;
+          k++;
+        } else if (j === leftLength && !(left = leftIterator.next()).done) {
+          leftLength = left.value.length;
+          j = 0;
+        } else if (k === rightLength && !(right = rightIterator.next()).done) {
+          rightLength = right.value.length;
+          k = 0;
+        }
       }
-    }
 
-    return out.result();
-  }
+      return out.result();
+    }
+  };
 }
 /**
  * @tsplus getter fncts.Conc zipWithIndex
@@ -1337,28 +1433,30 @@ function zipWith_1(self, fb, f) {
 
 
 export function zipWithIndex(self) {
-  return zipWithIndexOffset_1(self, 0);
+  return zipWithIndexOffset_1(0)(self);
 }
 /**
- * @tsplus fluent fncts.Conc zipWithIndexOffset
+ * @tsplus pipeable fncts.Conc zipWithIndexOffset
  */
 
-function zipWithIndexOffset_1(as, offset) {
-  void 0;
-  const iterator = as.arrayIterator();
-  let next;
-  let i = offset;
-  const out = builder_1();
+function zipWithIndexOffset_1(offset) {
+  return as => {
+    void 0;
+    const iterator = as.arrayIterator();
+    let next;
+    let i = offset;
+    const out = builder_1();
 
-  while (!(next = iterator.next()).done) {
-    const array = next.value;
-    const len = array.length;
+    while (!(next = iterator.next()).done) {
+      const array = next.value;
+      const len = array.length;
 
-    for (let j = 0; i < len; j++, i++) {
-      out.append([array[j], i]);
+      for (let j = 0; i < len; j++, i++) {
+        out.append([array[j], i]);
+      }
     }
-  }
 
-  return out.result();
+    return out.result();
+  };
 }
 //# sourceMappingURL=api.mjs.map