@fncts/base 0.0.20 → 0.0.21

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

@@ -3,59 +3,61 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.alignWith_ = exports.ConcBuilder = void 0;
-exports.align_ = align_;
-exports.builder = exports.append_ = void 0;
+exports._traverseWithIndex = exports._traverse = exports.ConcBuilder = void 0;
+exports.align = align;
+exports.builder = exports.append = exports.alignWith = void 0;
 exports.chainRecBreadthFirst = chainRecBreadthFirst;
 exports.chainRecDepthFirst = chainRecDepthFirst;
-exports.chop_ = void 0;
-exports.chunksOf_ = chunksOf_;
-exports.collectWhile_ = void 0;
+exports.chop = void 0;
+exports.chunksOf = chunksOf;
+exports.collectWhile = void 0;
 exports.compact = compact;
-exports.concat_ = void 0;
+exports.drop = exports.concat = void 0;
 exports.dropUntil = dropUntil;
-exports.dropWhile_ = dropWhile_;
-exports.drop_ = void 0;
-exports.elem_ = elem_;
-exports.filterWithIndex_ = exports.filterMap_ = exports.filterMapWithIndex_ = exports.exists_ = void 0;
-exports.filter_ = filter_;
-exports.find_ = find_;
-exports.flatMap_ = void 0;
+exports.dropWhile = dropWhile;
+exports.elem = elem;
+exports.exists = void 0;
+exports.filter = filter;
+exports.filterWithIndex = exports.filterMapWithIndex = exports.filterMap = void 0;
+exports.find = find;
+exports.flatMap = void 0;
 exports.flatten = flatten;
-exports.foldLeftWhile_ = foldLeftWhile_;
-exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = void 0;
-exports.foldMap_ = foldMap_;
-exports.foldRightWithIndex_ = void 0;
-exports.foldRight_ = foldRight_;
-exports.forEachWithIndex_ = forEachWithIndex_;
-exports.forEach_ = void 0;
-exports.get_ = get_;
+exports.foldLeft = void 0;
+exports.foldLeftWhile = foldLeftWhile;
+exports.foldLeftWithIndex = void 0;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = void 0;
+exports.foldRight = foldRight;
+exports.forEach = exports.foldRightWithIndex = void 0;
+exports.forEachWithIndex = forEachWithIndex;
+exports.get = get;
 exports.head = head;
 exports.init = init;
 exports.isNonEmpty = exports.isEmpty = void 0;
-exports.join_ = join_;
+exports.join = join;
 exports.last = last;
-exports.mapAccum_ = mapAccum_;
-exports.mapWithIndex_ = void 0;
-exports.map_ = map_;
-exports.partitionWithIndex_ = exports.partitionMap_ = exports.partitionMapWithIndex_ = void 0;
-exports.partition_ = partition_;
-exports.prepend_ = prepend_;
+exports.map = map;
+exports.mapAccum = mapAccum;
+exports.mapWithIndex = void 0;
+exports.partition = partition;
+exports.partitionWithIndex = exports.partitionMapWithIndex = exports.partitionMap = void 0;
+exports.prepend = prepend;
 exports.reverse = reverse;
 exports.separate = separate;
-exports.splitAt_ = void 0;
-exports.splitWhere_ = splitWhere_;
+exports.splitAt = void 0;
+exports.splitWhere = splitWhere;
 exports.tail = tail;
-exports.takeWhile_ = takeWhile_;
-exports.take_ = void 0;
+exports.take = void 0;
+exports.takeWhile = takeWhile;
 exports.toBuffer = toBuffer;
 exports.traverseWithIndex = exports.traverse = void 0;
 exports.unfold = unfold;
-exports.unsafeUpdateAt_ = exports.unsafeTail = exports.unsafeHead = exports.unsafeGet_ = void 0;
-exports.updateAt_ = updateAt_;
+exports.unsafeUpdateAt = exports.unsafeTail = exports.unsafeHead = exports.unsafeGet = void 0;
+exports.updateAt = updateAt;
+exports.zip = zip;
+exports.zipWith = void 0;
 exports.zipWithIndex = zipWithIndex;
-exports.zipWith_ = exports.zipWithIndexOffset_ = void 0;
-exports.zip_ = zip_;
+exports.zipWithIndexOffset = void 0;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/These/constructors"));
 
@@ -75,129 +77,135 @@ var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require
 
 var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/Iterable/constructors"));
 
-var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/TraversableWithIndex"));
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
 
-var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
-
-var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/exceptions"));
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/exceptions"));
 
 var _definition2 = /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/definition");
 
 var _function = /*#__PURE__*/require("@fncts/base/data/function");
 
-var P = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass"));
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const alignWith_ = alignWith_1;
-exports.alignWith_ = alignWith_;
-const append_ = append_1;
-exports.append_ = append_;
+const alignWith = alignWith_1;
+exports.alignWith = alignWith;
+const append = append_1;
+exports.append = append;
 const builder = builder_1;
 exports.builder = builder;
-const flatMap_ = flatMap_1;
-exports.flatMap_ = flatMap_;
-const chop_ = chop_1;
-exports.chop_ = chop_;
-const collectWhile_ = collectWhile_1;
-exports.collectWhile_ = collectWhile_;
-const concat_ = concat_1;
-exports.concat_ = concat_;
-const exists_ = exists_1;
-exports.exists_ = exists_;
-const drop_ = drop_1;
-exports.drop_ = drop_;
-const filterMap_ = filterMap_1;
-exports.filterMap_ = filterMap_;
-const filterMapWithIndex_ = filterMapWithIndex_1;
-exports.filterMapWithIndex_ = filterMapWithIndex_;
-const filterWithIndex_ = filterWithIndex_1;
-exports.filterWithIndex_ = filterWithIndex_;
-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 forEach_ = forEach_1;
-exports.forEach_ = forEach_;
-const mapWithIndex_ = mapWithIndex_1;
-exports.mapWithIndex_ = mapWithIndex_;
+const flatMap = flatMap_1;
+exports.flatMap = flatMap;
+const chop = chop_1;
+exports.chop = chop;
+const collectWhile = collectWhile_1;
+exports.collectWhile = collectWhile;
+const concat = concat_1;
+exports.concat = concat;
+const exists = exists_1;
+exports.exists = exists;
+const drop = drop_1;
+exports.drop = drop;
+const filterMap = filterMap_1;
+exports.filterMap = filterMap;
+const filterMapWithIndex = filterMapWithIndex_1;
+exports.filterMapWithIndex = filterMapWithIndex;
+const filterWithIndex = filterWithIndex_1;
+exports.filterWithIndex = filterWithIndex;
+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 forEach = forEach_1;
+exports.forEach = forEach;
+const mapWithIndex = mapWithIndex_1;
+exports.mapWithIndex = mapWithIndex;
 const isEmpty = isEmpty_1;
 exports.isEmpty = isEmpty;
 const isNonEmpty = isNonEmpty_1;
 exports.isNonEmpty = isNonEmpty;
-const partitionMap_ = partitionMap_1;
-exports.partitionMap_ = partitionMap_;
-const partitionMapWithIndex_ = partitionMapWithIndex_1;
-exports.partitionMapWithIndex_ = partitionMapWithIndex_;
-const partitionWithIndex_ = partitionWithIndex_1;
-exports.partitionWithIndex_ = partitionWithIndex_;
-const splitAt_ = splitAt_1;
-exports.splitAt_ = splitAt_;
-const take_ = take_1;
-exports.take_ = take_;
-const unsafeGet_ = unsafeGet_1;
-exports.unsafeGet_ = unsafeGet_;
+const partitionMap = partitionMap_1;
+exports.partitionMap = partitionMap;
+const partitionMapWithIndex = partitionMapWithIndex_1;
+exports.partitionMapWithIndex = partitionMapWithIndex;
+const partitionWithIndex = partitionWithIndex_1;
+exports.partitionWithIndex = partitionWithIndex;
+const splitAt = splitAt_1;
+exports.splitAt = splitAt;
+const take = take_1;
+exports.take = take;
+const _traverseWithIndex = _traverseWithIndex_1;
+exports._traverseWithIndex = _traverseWithIndex;
+const _traverse = _traverse_1;
+exports._traverse = _traverse;
+const unsafeGet = unsafeGet_1;
+exports.unsafeGet = unsafeGet;
 const unsafeHead = unsafeHead_1;
 exports.unsafeHead = unsafeHead;
 const unsafeTail = unsafeTail_1;
 exports.unsafeTail = unsafeTail;
-const unsafeUpdateAt_ = unsafeUpdateAt_1;
-exports.unsafeUpdateAt_ = unsafeUpdateAt_;
-const zipWith_ = zipWith_1;
-exports.zipWith_ = zipWith_;
-const zipWithIndexOffset_ = zipWithIndexOffset_1;
-exports.zipWithIndexOffset_ = zipWithIndexOffset_;
+const unsafeUpdateAt = unsafeUpdateAt_1;
+exports.unsafeUpdateAt = unsafeUpdateAt;
+const zipWith = zipWith_1;
+exports.zipWith = zipWith;
+const zipWithIndexOffset = zipWithIndexOffset_1;
+exports.zipWithIndexOffset = zipWithIndexOffset;
 
 /**
- * @tsplus fluent fncts.Conc align
+ * @tsplus pipeable fncts.Conc 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.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);
+  };
 }
 
 class ConcBuilder {
@@ -206,7 +214,7 @@ class ConcBuilder {
   }
 
   append(a) {
-    this.conc = append_1(this.conc, a);
+    this.conc = append_1(a)(this.conc);
     return this;
   }
 
@@ -226,27 +234,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
@@ -265,9 +275,9 @@ 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);
     }
   }
 
@@ -289,9 +299,9 @@ 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);
     }
   }
 
@@ -308,73 +318,79 @@ 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
  */
 
 
-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);
+  };
 }
 /**
  * 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
@@ -382,283 +398,305 @@ function collectWhile_1(as, f) {
 
 
 function compact(self) {
-  return filterMap_1(self, _function.identity);
+  return filterMap_1(_function.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
  */
 
 
-function elem_(self, a,
+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 _definition2.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 _definition2.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 _definition2.Slice(self, n, len - n);
+        default:
+          return new _definition2.Slice(self, n, len - n);
+      }
     }
-  }
+  };
 }
 /**
- * @tsplus fluent fncts.Conc dropUntil
+ * @tsplus pipeable fncts.Conc dropUntil
  */
 
 
-function dropUntil(self, p) {
-  let cont = true;
-  let i = 0;
+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
  */
 
 
-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++;
-        }
+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);
+        }
+    }
+  };
 }
 
-function filter_(self, p) {
-  return filterWithIndex_1(self, (_, a) => p(a));
+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 _definition2._Empty;
-      }
+    switch (self._tag) {
+      case "Empty"
+      /* ConcTag.Empty */
+      :
+        {
+          return _definition2._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 _definition2._Empty;
         }
 
-        return _definition2._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
  */
 
 
-function find_(self, f) {
-  void 0;
-  const iterator = self.arrayIterator();
-  let out = tsplus_module_6.nothing();
-  let result;
+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
@@ -666,141 +704,161 @@ function find_(self, f) {
 
 
 function flatten(self) {
-  return flatMap_1(self, _function.identity);
+  return flatMap_1(_function.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
  */
 
 
-function foldLeftWhile_(as, b, p, f) {
-  void 0;
-  const iterator = as.arrayIterator();
-  let s = b;
-  let cont = p(s);
-  let result;
+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
  */
 
 
-function foldMap_(fa, f,
+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
  */
 
 
-function foldRight_(fa, b, f) {
-  return foldRightWithIndex_1(fa, b, (_, a, b) => f(a, b));
+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
  */
 
 
-function forEachWithIndex_(self, f) {
-  void 0;
-  self.forEach(0, f);
+function forEachWithIndex(f) {
+  return self => {
+    void 0;
+    self.forEach(0, f);
+  };
 }
 /**
- * @tsplus fluent fncts.Conc get
+ * @tsplus pipeable fncts.Conc get
  */
 
 
-function get_(as, n) {
-  return tsplus_module_6.tryCatch(() => unsafeGet_1(as, n));
+function get(n) {
+  return as => {
+    return tsplus_module_6.tryCatch(() => unsafeGet_1(n)(as));
+  };
 }
 /**
  * @tsplus getter fncts.Conc head
@@ -826,19 +884,21 @@ 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
  */
 
 
-function join_(self, separator) {
-  if (self.length === 0) {
-    return "";
-  }
+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
@@ -855,47 +915,51 @@ function last(self) {
   return tsplus_module_6.just(self.get(self.length - 1));
 }
 /**
- * @tsplus fluent fncts.Conc map
+ * @tsplus pipeable fncts.Conc map
  */
 
 
-function map_(self, f) {
-  return mapWithIndex_1(self, (_, a) => f(a));
+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
  */
 
 
-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];
+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 (0, _function.tuple)(s, out.result());
+    return (0, _function.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;
@@ -905,7 +969,7 @@ function mapArrayLikeReverse(as, len, endIndex, f) {
   let bs = tsplus_module_2.empty();
 
   for (let i = _definition2.BUFFER_SIZE - len, j = len - 1; i < _definition2.BUFFER_SIZE; i++, j--) {
-    bs = append_1(bs, f(endIndex - j, as[i]));
+    bs = append_1(f(endIndex - j, as[i]))(bs);
   }
 
   return bs;
@@ -954,132 +1018,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();
+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 _definition2.Singleton(f(index++, current.value));
+              break pushing;
+            }
 
-  recursion: while (stack.hasNext) {
-    // eslint-disable-next-line no-constant-condition
-    pushing: while (true) {
-      void 0;
+          case "Empty"
+          /* ConcTag.Empty */
+          :
+            {
+              result = _definition2._Empty;
+              break pushing;
+            }
 
-      switch (current._tag) {
-        case "Singleton"
-        /* ConcTag.Singleton */
-        :
-          {
-            result = new _definition2.Singleton(f(index++, current.value));
-            break pushing;
-          }
+          case "Chunk"
+          /* ConcTag.Chunk */
+          :
+            {
+              result = new _definition2.Chunk(current._array.map((a, i) => f(i + index, a)));
+              index += current.length;
+              break pushing;
+            }
 
-        case "Empty"
-        /* ConcTag.Empty */
-        :
-          {
-            result = _definition2._Empty;
-            break pushing;
-          }
+          case "Concat"
+          /* ConcTag.Concat */
+          :
+            {
+              stack.push(new ConcatLeftFrame(current, index));
+              current = current.left;
+              continue pushing;
+            }
 
-        case "Chunk"
-        /* ConcTag.Chunk */
-        :
-          {
-            result = new _definition2.Chunk(current._array.map((a, i) => f(i + index, a)));
-            index += current.length;
-            break pushing;
-          }
+          case "AppendN"
+          /* ConcTag.AppendN */
+          :
+            {
+              stack.push(new AppendFrame(current.buffer, current.bufferUsed, index));
+              current = current.start;
+              continue pushing;
+            }
 
-        case "Concat"
-        /* ConcTag.Concat */
-        :
-          {
-            stack.push(new ConcatLeftFrame(current, index));
-            current = current.left;
-            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 "AppendN"
-        /* ConcTag.AppendN */
-        :
-          {
-            stack.push(new AppendFrame(current.buffer, current.bufferUsed, index));
-            current = current.start;
-            continue pushing;
-          }
+          case "Slice"
+          /* ConcTag.Slice */
+          :
+            {
+              let r = tsplus_module_2.empty();
 
-        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();
+              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
@@ -1099,77 +1165,87 @@ function isNonEmpty_1(conc) {
   return !isEmpty_1(conc);
 }
 
-function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.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
  */
 
 
-function prepend_(self, a) {
-  void 0;
-  return self.prepend(a);
+function prepend(a) {
+  return self => {
+    void 0;
+    return self.prepend(a);
+  };
 }
 /**
  * @tsplus getter fncts.Conc reverse
@@ -1179,7 +1255,7 @@ function prepend_(self, a) {
 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: () => {
@@ -1206,48 +1282,52 @@ function reverse(self) {
 
 
 function separate(self) {
-  return partitionMap_1(self, _function.identity);
+  return partitionMap_1(_function.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
  */
 
 
-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++;
+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
@@ -1259,91 +1339,100 @@ 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
  */
 
 
-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++;
-        }
+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 take_1(self, i);
-      }
-  }
+          return self.take(i);
+        }
+    }
+  };
 }
-/**
- * @tsplus getter fncts.Conc traverse
- */
 
+const traverse = G => f => self => _traverse_1(self)(G)(f);
+
+exports.traverse = traverse;
+
+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));
+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 traverseWithIndex
+ * @tsplus getter fncts.Conc traverse
  */
 
 
-exports.traverse = traverse;
-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))));
-const traverseWithIndex = traverseWithIndex_1;
+function _traverse_1(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
 /**
  * @tsplus getter fncts.Conc toBuffer
  */
 
-exports.traverseWithIndex = traverseWithIndex;
 
 function toBuffer(self) {
   void 0;
   return self.arrayLike();
 }
 /**
- * @tsplus fluent fncts.ConcOps unfold
+ * @tsplus static fncts.ConcOps unfold
  */
 
 
@@ -1364,14 +1453,16 @@ 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
@@ -1399,84 +1490,92 @@ 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
  */
 
 
-function updateAt_(self, i, a) {
-  try {
-    return tsplus_module_6.just(unsafeUpdateAt_1(self, i, a));
-  } catch {
-    return tsplus_module_6.nothing();
-  }
+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
  */
 
 
-function zip_(self, fb) {
-  return zipWith_1(self, fb, _function.tuple);
+function zip(fb) {
+  return self => {
+    return zipWith_1(fb, _function.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
@@ -1484,29 +1583,31 @@ function zipWith_1(self, fb, f) {
 
 
 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.cjs.map