@fncts/base 0.0.20 → 0.0.22

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

@@ -3,277 +3,259 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.append_ = void 0;
-exports.chunksOf_ = chunksOf_;
-exports.concat_ = void 0;
-exports.contains_ = contains_;
-exports.dropLast_ = dropLast_;
+exports._traverse = _traverse;
+exports.append = exports._traverseWithIndex = void 0;
+exports.chunksOf = chunksOf;
+exports.concat = void 0;
+exports.contains = contains;
+exports.drop = drop;
+exports.dropLast = dropLast;
 exports.dropRepeats = dropRepeats;
-exports.dropRepeatsWith_ = void 0;
-exports.dropWhile_ = dropWhile_;
-exports.drop_ = drop_;
-exports.elem_ = elem_;
+exports.dropRepeatsWith = void 0;
+exports.dropWhile = dropWhile;
+exports.elem = elem;
 exports.emptyPushable = exports.empty = void 0;
-exports.equals_ = equals_;
-exports.every_ = every_;
-exports.findIndex_ = exports.exists_ = void 0;
-exports.findLastIndex_ = findLastIndex_;
-exports.findLast_ = findLast_;
-exports.find_ = find_;
-exports.flatMap_ = flatMap_;
-exports.flatten = void 0;
-exports.foldLeftWhile_ = foldLeftWhile_;
-exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = void 0;
-exports.foldMap_ = foldMap_;
-exports.foldRightWhile_ = foldRightWhile_;
-exports.foldRightWithIndex_ = void 0;
-exports.foldRight_ = foldRight_;
-exports.forEachWithIndex_ = forEachWithIndex_;
-exports.forEach_ = void 0;
+exports.equals = equals;
+exports.every = every;
+exports.find = find;
+exports.findIndex = void 0;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
+exports.flatMap = flatMap;
+exports.foldLeft = exports.flatten = void 0;
+exports.foldLeftWhile = foldLeftWhile;
+exports.foldLeftWithIndex = void 0;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = void 0;
+exports.foldRight = foldRight;
+exports.foldRightWhile = foldRightWhile;
+exports.forEach = exports.foldRightWithIndex = void 0;
+exports.forEachWithIndex = forEachWithIndex;
 exports.from = from;
-exports.get_ = get_;
-exports.groupWith_ = groupWith_;
+exports.get = get;
+exports.groupWith = groupWith;
 exports.head = head;
-exports.indexOf_ = indexOf_;
-exports.insertAllAt_ = insertAllAt_;
-exports.insertAt_ = insertAt_;
-exports.intersperse_ = intersperse_;
+exports.indexOf = indexOf;
+exports.insertAllAt = insertAllAt;
+exports.insertAt = insertAt;
+exports.intersperse = intersperse;
 exports.isEmpty = isEmpty;
 exports.isNonEmpty = isNonEmpty;
-exports.join_ = join_;
+exports.join = join;
 exports.last = last;
-exports.lastIndexOf_ = lastIndexOf_;
+exports.lastIndexOf = lastIndexOf;
 exports.makeBy = makeBy;
-exports.mapAccum_ = mapAccum_;
-exports.map_ = exports.mapWithIndex_ = void 0;
-exports.modifyAt_ = modifyAt_;
+exports.map = void 0;
+exports.mapAccum = mapAccum;
+exports.mapWithIndex = void 0;
+exports.modifyAt = modifyAt;
 exports.mutableClone = void 0;
-exports.none_ = none_;
+exports.none = none;
 exports.pair = pair;
-exports.pop = void 0;
+exports.prepend = exports.pop = void 0;
 exports.prependOperator = prependOperator;
-exports.prepend_ = void 0;
 exports.range = range;
-exports.remove_ = remove_;
+exports.remove = remove;
 exports.replicate = replicate;
 exports.reverse = reverse;
-exports.scanLeft_ = scanLeft_;
+exports.scanLeft = scanLeft;
 exports.single = single;
-exports.sortWith_ = exports.slice_ = void 0;
-exports.sort_ = sort_;
-exports.splitAt_ = void 0;
-exports.splitWhen_ = splitWhen_;
+exports.some = exports.slice = void 0;
+exports.sort = sort;
+exports.splitAt = exports.sortWith = void 0;
+exports.splitWhen = splitWhen;
 exports.tail = tail;
-exports.takeLastWhile_ = takeLastWhile_;
-exports.takeLast_ = takeLast_;
-exports.takeWhile_ = takeWhile_;
-exports.take_ = take_;
+exports.take = take;
+exports.takeLast = takeLast;
+exports.takeLastWhile = takeLastWhile;
+exports.takeWhile = takeWhile;
 exports.toArray = toArray;
 exports.toList = toList;
 exports.traverseWithIndex = exports.traverse = void 0;
 exports.unfold = unfold;
 exports.uniq = uniq;
-exports.vector = exports.updateAt_ = exports.unsafeLast = exports.unsafeHead = exports.unsafeGet_ = exports.unsafeFind_ = exports.unsafeFindLast_ = void 0;
-
+exports.vector = exports.updateAt = exports.unsafeLast = exports.unsafeHead = exports.unsafeGet = exports.unsafeFindLast = exports.unsafeFind = void 0;
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector"));
-
 var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/internal"));
-
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Equatable/api"));
-
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Equatable/api"));
 var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/definition"));
-
 var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
-
 var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/mutable/ListBuffer"));
-
-var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/TraversableWithIndex"));
-
-var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
-
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
 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 append_ = append_1;
-exports.append_ = append_;
-const concat_ = concat_1;
-exports.concat_ = concat_;
-const dropRepeatsWith_ = dropRepeatsWith_1;
-exports.dropRepeatsWith_ = dropRepeatsWith_;
+const append = append_1;
+exports.append = append;
+const concat = concat_1;
+exports.concat = concat;
+const dropRepeatsWith = dropRepeatsWith_1;
+exports.dropRepeatsWith = dropRepeatsWith;
 const empty = empty_1;
 exports.empty = empty;
 const emptyPushable = emptyPushable_1;
 exports.emptyPushable = emptyPushable;
-const exists_ = exists_1;
-exports.exists_ = exists_;
-const findIndex_ = findIndex_1;
-exports.findIndex_ = findIndex_;
+const some = some_1;
+exports.some = some;
+const findIndex = findIndex_1;
+exports.findIndex = findIndex;
 const flatten = flatten_1;
 exports.flatten = flatten;
-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 map_ = map_1;
-exports.map_ = map_;
-const mapWithIndex_ = mapWithIndex_1;
-exports.mapWithIndex_ = mapWithIndex_;
+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 map = map_1;
+exports.map = map;
+const mapWithIndex = mapWithIndex_1;
+exports.mapWithIndex = mapWithIndex;
 const mutableClone = mutableClone_1;
 exports.mutableClone = mutableClone;
 const pop = pop_1;
 exports.pop = pop;
-const prepend_ = prepend_1;
-exports.prepend_ = prepend_;
-const slice_ = slice_1;
-exports.slice_ = slice_;
-const sortWith_ = sortWith_1;
-exports.sortWith_ = sortWith_;
-const splitAt_ = splitAt_1;
-exports.splitAt_ = splitAt_;
-const unsafeFind_ = unsafeFind_1;
-exports.unsafeFind_ = unsafeFind_;
-const unsafeFindLast_ = unsafeFindLast_1;
-exports.unsafeFindLast_ = unsafeFindLast_;
-const unsafeGet_ = unsafeGet_1;
-exports.unsafeGet_ = unsafeGet_;
+const prepend = prepend_1;
+exports.prepend = prepend;
+const slice = slice_1;
+exports.slice = slice;
+const sortWith = sortWith_1;
+exports.sortWith = sortWith;
+const splitAt = splitAt_1;
+exports.splitAt = splitAt;
+const _traverseWithIndex = _traverseWithIndex_1;
+exports._traverseWithIndex = _traverseWithIndex;
+const unsafeFind = unsafeFind_1;
+exports.unsafeFind = unsafeFind;
+const unsafeFindLast = unsafeFindLast_1;
+exports.unsafeFindLast = unsafeFindLast;
+const unsafeGet = unsafeGet_1;
+exports.unsafeGet = unsafeGet;
 const unsafeHead = unsafeHead_1;
 exports.unsafeHead = unsafeHead;
 const unsafeLast = unsafeLast_1;
 exports.unsafeLast = unsafeLast;
-const updateAt_ = updateAt_1;
-exports.updateAt_ = updateAt_;
+const updateAt = updateAt_1;
+exports.updateAt = updateAt;
 const vector = vector_1;
 exports.vector = vector;
-
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector append
- * @tsplus operator fncts.Vector +
+ * @tsplus pipeable fncts.Vector append
+ * @tsplus pipeable-operator fncts.Vector +
  */
-function append_1(as, a) {
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(as);
-
-  if (suffixSize < 32) {
-    return new tsplus_module_1.Vector((0, tsplus_module_2.incrementSuffix)(as.bits), as.offset, as.length + 1, as.prefix, as.root, (0, tsplus_module_2.affixPush)(a, as.suffix, suffixSize));
-  }
-
-  const newSuffix = [a];
-  const newVector = mutableClone_1(as);
-  (0, tsplus_module_2.appendNodeToTree)(newVector, as.suffix);
-  newVector.suffix = newSuffix;
-  newVector.length++;
-  newVector.bits = (0, tsplus_module_2.setSuffix)(1, newVector.bits);
-  return newVector;
+function append_1(a) {
+  return self => {
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    if (suffixSize < 32) {
+      return new tsplus_module_1.Vector((0, tsplus_module_2.incrementSuffix)(self.bits), self.offset, self.length + 1, self.prefix, self.root, (0, tsplus_module_2.affixPush)(a, self.suffix, suffixSize));
+    }
+    const newSuffix = [a];
+    const newVector = mutableClone_1(self);
+    (0, tsplus_module_2.appendNodeToTree)(newVector, self.suffix);
+    newVector.suffix = newSuffix;
+    newVector.length++;
+    newVector.bits = (0, tsplus_module_2.setSuffix)(1, newVector.bits);
+    return newVector;
+  };
 }
 /**
  * Maps a function over a Vector and concatenates all the resulting
  * Vectors together.
  *
- * @tsplus fluent fncts.Vector flatMap
+ * @tsplus pipeable fncts.Vector flatMap
  */
-
-
-function flatMap_(ma, f) {
-  return flatten_1(map_1(ma, f));
+function flatMap(f) {
+  return self => {
+    return flatten_1(map_1(f)(self));
+  };
 }
 /**
  * Splits the Vector into chunks of the given size.
  *
- * @tsplus fluent fncts.Vector chunksOf
- */
-
-
-function chunksOf_(as, size) {
-  const {
-    buffer,
-    l2
-  } = foldLeft_1(as, {
-    l2: emptyPushable_1(),
-    buffer: emptyPushable_1()
-  }, ({
-    buffer,
-    l2
-  }, elem) => {
-    tsplus_module_2.push(buffer, elem);
-
-    if (buffer.length === size) {
-      return {
-        l2: tsplus_module_2.push(l2, buffer),
-        buffer: emptyPushable_1()
-      };
-    } else {
-      return {
-        l2,
-        buffer
-      };
-    }
-  });
-  return buffer.length === 0 ? l2 : tsplus_module_2.push(l2, buffer);
+ * @tsplus pipeable fncts.Vector chunksOf
+ */
+function chunksOf(size) {
+  return self => {
+    const {
+      buffer,
+      l2
+    } = foldLeft_1({
+      l2: emptyPushable_1(),
+      buffer: emptyPushable_1()
+    }, ({
+      buffer,
+      l2
+    }, elem) => {
+      tsplus_module_2.push(elem)(buffer);
+      if (buffer.length === size) {
+        return {
+          l2: tsplus_module_2.push(buffer)(l2),
+          buffer: emptyPushable_1()
+        };
+      } else {
+        return {
+          l2,
+          buffer
+        };
+      }
+    })(self);
+    return buffer.length === 0 ? l2 : tsplus_module_2.push(buffer)(l2);
+  };
 }
-
-function concat_1(self, that) {
-  if (self.length === 0) {
-    return that;
-  } else if (that.length === 0) {
-    return self;
-  }
-
-  const newSize = self.length + that.length;
-  const rightSuffixSize = (0, tsplus_module_2.getSuffixSize)(that);
-  let newVector = mutableClone_1(self);
-
-  if (that.root === undefined) {
-    // right is nothing but a prefix and a suffix
-    const nrOfAffixes = (0, tsplus_module_2.concatAffixes)(self, that);
-
-    for (let i = 0; i < nrOfAffixes; ++i) {
-      newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, tsplus_module_2.concatBuffer[i]);
-      newVector.length += tsplus_module_2.concatBuffer[i].length; // wipe pointer, otherwise it might end up keeping the array alive
-
-      tsplus_module_2.concatBuffer[i] = undefined;
+function concat_1(that) {
+  return self => {
+    if (self.length === 0) {
+      return that;
+    } else if (that.length === 0) {
+      return self;
     }
-
-    newVector.length = newSize;
-    newVector.suffix = tsplus_module_2.concatBuffer[nrOfAffixes];
-    newVector.bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.concatBuffer[nrOfAffixes].length, newVector.bits);
-    tsplus_module_2.concatBuffer[nrOfAffixes] = undefined;
-    return newVector;
-  } else {
-    const leftSuffixSize = (0, tsplus_module_2.getSuffixSize)(self);
-
-    if (leftSuffixSize > 0) {
-      newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, self.suffix.slice(0, leftSuffixSize));
-      newVector.length += leftSuffixSize;
+    const newSize = self.length + that.length;
+    const rightSuffixSize = (0, tsplus_module_2.getSuffixSize)(that);
+    let newVector = mutableClone_1(self);
+    if (that.root === undefined) {
+      // right is nothing but a prefix and a suffix
+      const nrOfAffixes = (0, tsplus_module_2.concatAffixes)(self, that);
+      for (let i = 0; i < nrOfAffixes; ++i) {
+        newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, tsplus_module_2.concatBuffer[i]);
+        newVector.length += tsplus_module_2.concatBuffer[i].length;
+        // wipe pointer, otherwise it might end up keeping the array alive
+        tsplus_module_2.concatBuffer[i] = undefined;
+      }
+      newVector.length = newSize;
+      newVector.suffix = tsplus_module_2.concatBuffer[nrOfAffixes];
+      newVector.bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.concatBuffer[nrOfAffixes].length, newVector.bits);
+      tsplus_module_2.concatBuffer[nrOfAffixes] = undefined;
+      return newVector;
+    } else {
+      const leftSuffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+      if (leftSuffixSize > 0) {
+        newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, self.suffix.slice(0, leftSuffixSize));
+        newVector.length += leftSuffixSize;
+      }
+      newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, that.prefix.slice(0, (0, tsplus_module_2.getPrefixSize)(that)).reverse());
+      const newNode = (0, tsplus_module_2.concatSubTree)(newVector.root, (0, tsplus_module_2.getDepth)(newVector), that.root, (0, tsplus_module_2.getDepth)(that), true);
+      const newDepth = (0, tsplus_module_2.getHeight)(newNode);
+      (0, tsplus_module_2.setSizes)(newNode, newDepth);
+      newVector.root = newNode;
+      newVector.offset &= ~(tsplus_module_2.mask << (0, tsplus_module_2.getDepth)(self) * tsplus_module_2.branchBits);
+      newVector.length = newSize;
+      newVector.bits = (0, tsplus_module_2.setSuffix)(rightSuffixSize, (0, tsplus_module_2.setDepth)(newDepth, newVector.bits));
+      newVector.suffix = that.suffix;
+      return newVector;
     }
-
-    newVector = (0, tsplus_module_2.appendNodeToTree)(newVector, that.prefix.slice(0, (0, tsplus_module_2.getPrefixSize)(that)).reverse());
-    const newNode = (0, tsplus_module_2.concatSubTree)(newVector.root, (0, tsplus_module_2.getDepth)(newVector), that.root, (0, tsplus_module_2.getDepth)(that), true);
-    const newDepth = (0, tsplus_module_2.getHeight)(newNode);
-    (0, tsplus_module_2.setSizes)(newNode, newDepth);
-    newVector.root = newNode;
-    newVector.offset &= ~(tsplus_module_2.mask << (0, tsplus_module_2.getDepth)(self) * tsplus_module_2.branchBits);
-    newVector.length = newSize;
-    newVector.bits = (0, tsplus_module_2.setSuffix)(rightSuffixSize, (0, tsplus_module_2.setDepth)(newDepth, newVector.bits));
-    newVector.suffix = that.suffix;
-    return newVector;
-  }
+  };
 }
-
 const containsState = {
   element: undefined,
   result: false
 };
-
 function containsCb(value, state) {
   return !(state.result = value === state.element);
 }
@@ -282,36 +264,36 @@ function containsCb(value, state) {
  * Otherwise it returns `false`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector contains
+ * @tsplus pipeable fncts.Vector contains
  */
-
-
-function contains_(as, element) {
-  containsState.element = element;
-  containsState.result = false;
-  return (0, tsplus_module_2.foldLeftCb)(containsCb, containsState, as).result;
+function contains(element) {
+  return self => {
+    containsState.element = element;
+    containsState.result = false;
+    return (0, tsplus_module_2.foldLeftCb)(containsCb, containsState, self).result;
+  };
 }
 /**
  * Returns a new Vector without the first `n` elements.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector drop
+ * @tsplus pipeable fncts.Vector drop
  */
-
-
-function drop_(as, n) {
-  return slice_1(as, n, as.length);
+function drop(n) {
+  return self => {
+    return slice_1(n, self.length)(self);
+  };
 }
 /**
  * Returns a new Vector without the last `n` elements.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector dropLast
+ * @tsplus pipeable fncts.Vector dropLast
  */
-
-
-function dropLast_(as, n) {
-  return slice_1(as, 0, as.length - n);
+function dropLast(n) {
+  return self => {
+    return slice_1(0, self.length - n)(self);
+  };
 }
 /**
  * Returns a new Vector without repeated elements.
@@ -319,24 +301,21 @@ function dropLast_(as, n) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector dropRepeats
  */
-
-
-function dropRepeats(as) {
-  return dropRepeatsWith_1(as, tsplus_module_3.strictEquals);
+function dropRepeats(self) {
+  return dropRepeatsWith_1(tsplus_module_3.strictEquals)(self);
 }
 /**
  * Returns a new Vector without repeated elements by using the given
  * function to determine when elements are equal.
  *
  * @complexity `O(n)`
- * @tsplus fluent fncts.Vector dropRepeatsWith
+ * @tsplus pipeable fncts.Vector dropRepeatsWith
  */
-
-
-function dropRepeatsWith_1(as, predicate) {
-  return foldLeft_1(as, emptyPushable_1(), (acc, a) => acc.length !== 0 && predicate(unsafeLast_1(acc), a) ? acc : tsplus_module_2.push(acc, a));
+function dropRepeatsWith_1(predicate) {
+  return self => {
+    return foldLeft_1(emptyPushable_1(), (acc, a) => acc.length !== 0 && predicate(unsafeLast_1(acc), a) ? acc : tsplus_module_2.push(a)(acc))(self);
+  };
 }
-
 function findNotIndexCb(value, state) {
   if (state.predicate(value)) {
     ++state.index;
@@ -351,62 +330,57 @@ function findNotIndexCb(value, state) {
  *
  * @complexity `O(k + log(n))` where `k` is the number of elements
  * satisfying the predicate.
- * @tsplus fluent fncts.Vector dropWhile
- */
-
-
-function dropWhile_(as, predicate) {
-  const {
-    index
-  } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, index, as.length);
+ * @tsplus pipeable fncts.Vector dropWhile
+ */
+function dropWhile(predicate) {
+  return self => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, self);
+    return slice_1(index, self.length)(self);
+  };
 }
-
 function elemCb(value, state) {
-  return !(state.result = state.equals(value, state.element));
+  return !(state.result = state.equals(state.element)(value));
 }
 /**
- * @tsplus getter fncts.Vector elem
+ * @tsplus pipeable fncts.Vector elem
  */
-
-
-function elem_(self) {
-  return E => {
-    const elemState = {
-      equals: E.equals,
-      element: undefined,
-      result: false
-    };
-    return a => {
-      elemState.element = a;
-      return (0, tsplus_module_2.foldLeftCb)(elemCb, elemState, self).result;
-    };
+function elem(a, /** @tsplus auto */E) {
+  const elemState = {
+    equals: E.equals,
+    element: undefined,
+    result: false
+  };
+  return self => {
+    elemState.element = a;
+    return (0, tsplus_module_2.foldLeftCb)(elemCb, elemState, self).result;
   };
 }
 /**
  * Returns true if the two Vectors are equivalent.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector equals
+ * @tsplus pipeable fncts.Vector equals
  */
-
-
-function equals_(self, that) {
-  return tsplus_module_4.corresponds_(self, that, tsplus_module_3.strictEquals);
+function equals(that) {
+  return self => {
+    return tsplus_module_4.corresponds(that, tsplus_module_3.strictEquals)(self);
+  };
 }
-
 function everyCb(value, state) {
   return state.result = state.predicate(value);
 }
-
-function every_(as, predicate) {
-  return (0, tsplus_module_2.foldLeftCb)(everyCb, {
-    predicate,
-    result: true
-  }, as).result;
+function every(predicate) {
+  return self => {
+    return (0, tsplus_module_2.foldLeftCb)(everyCb, {
+      predicate,
+      result: true
+    }, self).result;
+  };
 }
 /**
  * Creates an empty Vector.
@@ -414,21 +388,16 @@ function every_(as, predicate) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps empty
  */
-
-
 function empty_1() {
   return new tsplus_module_1.Vector(0, 0, 0, tsplus_module_2.emptyAffix, undefined, tsplus_module_2.emptyAffix);
 }
 /**
  * @tsplus static fncts.VectorOps emptyPushable
  */
-
-
 function emptyPushable_1() {
   return new tsplus_module_1.Vector(0, 0, 0, [], undefined, []);
 }
-
-function existsCb(value, state) {
+function someCb(value, state) {
   return !(state.result = state.predicate(value));
 }
 /**
@@ -437,29 +406,28 @@ function existsCb(value, state) {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector exists
+ * @tsplus pipeable fncts.Vector some
  */
-
-
-function exists_1(as, predicate) {
-  return (0, tsplus_module_2.foldLeftCb)(existsCb, {
-    predicate,
-    result: false
-  }, as).result;
+function some_1(predicate) {
+  return self => {
+    return (0, tsplus_module_2.foldLeftCb)(someCb, {
+      predicate,
+      result: false
+    }, self).result;
+  };
 }
 /**
  * Returns the _first_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector find
+ * @tsplus pipeable fncts.Vector find
  */
-
-
-function find_(as, predicate) {
-  return tsplus_module_5.fromNullable(unsafeFind_1(as, predicate));
+function find(predicate) {
+  return self => {
+    return tsplus_module_5.fromNullable(unsafeFind_1(predicate)(self));
+  };
 }
-
 function findIndexCb(value, state) {
   ++state.index;
   return !(state.found = state.predicate(value));
@@ -470,32 +438,32 @@ function findIndexCb(value, state) {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findIndex
- */
-
-
-function findIndex_1(as, predicate) {
-  const {
-    found,
-    index
-  } = (0, tsplus_module_2.foldLeftCb)(findIndexCb, {
-    predicate,
-    found: false,
-    index: -1
-  }, as);
-  return found ? index : -1;
+ * @tsplus pipeable fncts.Vector findIndex
+ */
+function findIndex_1(predicate) {
+  return self => {
+    const {
+      found,
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findIndexCb, {
+      predicate,
+      found: false,
+      index: -1
+    }, self);
+    return found ? index : -1;
+  };
 }
 /**
  * Returns the _last_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLast
+ * @tsplus pipeable fncts.Vector findLast
  */
-
-
-function findLast_(as, predicate) {
-  return tsplus_module_5.fromNullable(unsafeFindLast_1(as, predicate));
+function findLast(predicate) {
+  return self => {
+    return tsplus_module_5.fromNullable(unsafeFindLast_1(predicate)(self));
+  };
 }
 /**
  * Returns the index of the `last` element for which the predicate
@@ -503,20 +471,20 @@ function findLast_(as, predicate) {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLastIndex
- */
-
-
-function findLastIndex_(as, predicate) {
-  const {
-    found,
-    index
-  } = (0, tsplus_module_2.foldRightCb)(findIndexCb, {
-    predicate,
-    found: false,
-    index: -0
-  }, as);
-  return found ? index : -1;
+ * @tsplus pipeable fncts.Vector findLastIndex
+ */
+function findLastIndex(predicate) {
+  return self => {
+    const {
+      found,
+      index
+    } = (0, tsplus_module_2.foldRightCb)(findIndexCb, {
+      predicate,
+      found: false,
+      index: -0
+    }, self);
+    return found ? index : -1;
+  };
 }
 /**
  * Flattens a Vector of Vectors into a Vector. Note that this function does
@@ -526,55 +494,47 @@ function findLastIndex_(as, predicate) {
  *
  * @tsplus getter fncts.Vector flatten
  */
-
-
-function flatten_1(mma) {
-  return foldLeft_1(mma, empty_1(), (acc, a) => concat_1(acc, a));
+function flatten_1(self) {
+  return foldLeft_1(empty_1(), (acc, a) => concat_1(a)(acc))(self);
 }
-
 function from(sequence) {
   const l = emptyPushable_1();
-
   if (sequence.length > 0 && (sequence[0] !== undefined || 0 in sequence)) {
     for (let i = 0; i < sequence.length; ++i) {
-      tsplus_module_2.push(l, sequence[i]);
+      tsplus_module_2.push(sequence[i])(l);
     }
   } else if (Symbol.iterator in sequence) {
     const iterator = sequence[Symbol.iterator]();
     let cur;
-
     while (!(cur = iterator.next()).done) {
-      tsplus_module_2.push(l, cur.value);
+      tsplus_module_2.push(cur.value)(l);
     }
   }
-
   return l;
 }
 /**
  * Folds a function over a Vector. Left-associative.
  *
- * @tsplus fluent fncts.Vector foldLeft
+ * @tsplus pipeable fncts.Vector foldLeft
  */
-
-
-function foldLeft_1(fa, initial, f) {
-  return foldLeftWithIndex_1(fa, initial, (_, b, a) => f(b, a));
+function foldLeft_1(initial, f) {
+  return self => {
+    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldLeftWithIndex
+ * @tsplus pipeable fncts.Vector foldLeftWithIndex
  */
-
-
-function foldLeftWithIndex_1(fa, b, f) {
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(fa);
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(fa);
-  let [acc, index] = (0, tsplus_module_2.foldLeftPrefix)(f, b, fa.prefix, prefixSize);
-
-  if (fa.root !== undefined) {
-    [acc, index] = (0, tsplus_module_2.foldLeftNode)(f, acc, fa.root, (0, tsplus_module_2.getDepth)(fa), index);
-  }
-
-  return (0, tsplus_module_2.foldLeftSuffix)(f, acc, fa.suffix, suffixSize, index)[0];
+function foldLeftWithIndex_1(b, f) {
+  return self => {
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    let [acc, index] = (0, tsplus_module_2.foldLeftPrefix)(f, b, self.prefix, prefixSize);
+    if (self.root !== undefined) {
+      [acc, index] = (0, tsplus_module_2.foldLeftNode)(f, acc, self.root, (0, tsplus_module_2.getDepth)(self), index);
+    }
+    return (0, tsplus_module_2.foldLeftSuffix)(f, acc, self.suffix, suffixSize, index)[0];
+  };
 }
 /**
  * Similar to `foldl`. But, for each element it calls the predicate function
@@ -590,93 +550,83 @@ function foldLeftWithIndex_1(fa, b, f) {
  * const ys = V.vector(2, 4, 6);
  * foldlWhile(isOdd, (n, m) => n + m, 111, ys) //=> 111
  */
-
-
 function foldWhileCb(a, state, i) {
   if (state.predicate(state.result) === false) {
     return false;
   }
-
   state.result = state.f(i, state.result, a);
   return true;
 }
 /**
- * @tsplus fluent fncts.Vector foldLeftWhile
+ * @tsplus pipeable fncts.Vector foldLeftWhile
  */
-
-
-function foldLeftWhile_(fa, b, cont, f) {
-  if (!cont(b)) {
-    return b;
-  }
-
-  return (0, tsplus_module_2.foldLeftCb)(foldWhileCb, {
-    predicate: cont,
-    f,
-    result: b
-  }, fa).result;
+function foldLeftWhile(b, cont, f) {
+  return self => {
+    if (!cont(b)) {
+      return b;
+    }
+    return (0, tsplus_module_2.foldLeftCb)(foldWhileCb, {
+      predicate: cont,
+      f,
+      result: b
+    }, self).result;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldRightWhile
+ * @tsplus pipeable fncts.Vector foldRightWhile
  */
-
-
-function foldRightWhile_(fa, b, cont, f) {
-  return (0, tsplus_module_2.foldRightCb)(foldWhileCb, {
-    predicate: cont,
-    result: b,
-    f: (i, b, a) => f(i, a, b)
-  }, fa).result;
+function foldRightWhile(b, cont, f) {
+  return self => {
+    return (0, tsplus_module_2.foldRightCb)(foldWhileCb, {
+      predicate: cont,
+      result: b,
+      f: (i, b, a) => f(i, a, b)
+    }, self).result;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldMap
+ * @tsplus pipeable fncts.Vector foldMap
  */
-
-
-function foldMap_(self, f,
-/** @tsplus auto */
-M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+function foldMap(f, /** @tsplus auto */M) {
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldMapWithIndex
+ * @tsplus pipeable fncts.Vector foldMapWithIndex
  */
-
-
-function foldMapWithIndex_1(self, f,
-/** @tsplus auto */
-M) {
-  return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+function foldMapWithIndex_1(f, /** @tsplus auto */M) {
+  return self => {
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(f(i, a))(b))(self);
+  };
 }
 /**
  * Folds a function over a Vector. Right-associative.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRight
+ * @tsplus pipeable fncts.Vector foldRight
  */
-
-
-function foldRight_(fa, initial, f) {
-  return foldRightWithIndex_1(fa, initial, (_, a, b) => f(a, b));
+function foldRight(initial, f) {
+  return self => {
+    return foldRightWithIndex_1(initial, (_, a, b) => f(a, b))(self);
+  };
 }
 /**
  * Folds a function over a Vector. Right-associative.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRightWithIndex
- */
-
-
-function foldRightWithIndex_1(fa, b, f) {
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(fa);
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(fa);
-  let [acc, j] = (0, tsplus_module_2.foldRightSuffix)(f, b, fa.suffix, suffixSize, fa.length - 1);
-
-  if (fa.root !== undefined) {
-    [acc, j] = (0, tsplus_module_2.foldRightNode)(f, acc, fa.root, (0, tsplus_module_2.getDepth)(fa), j);
-  }
-
-  return (0, tsplus_module_2.foldRightPrefix)(f, acc, fa.prefix, prefixSize, j)[0];
+ * @tsplus pipeable fncts.Vector foldRightWithIndex
+ */
+function foldRightWithIndex_1(b, f) {
+  return self => {
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    let [acc, j] = (0, tsplus_module_2.foldRightSuffix)(f, b, self.suffix, suffixSize, self.length - 1);
+    if (self.root !== undefined) {
+      [acc, j] = (0, tsplus_module_2.foldRightNode)(f, acc, self.root, (0, tsplus_module_2.getDepth)(self), j);
+    }
+    return (0, tsplus_module_2.foldRightPrefix)(f, acc, self.prefix, prefixSize, j)[0];
+  };
 }
 /**
  * Invokes a given callback for each element in the Vector from left to
@@ -688,32 +638,32 @@ function foldRightWithIndex_1(fa, b, f) {
  * makes `forEach` faster when the new Vector is unneeded.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector forEach
+ * @tsplus pipeable fncts.Vector forEach
  */
-
-
-function forEach_1(as, f) {
-  foldLeft_1(as, undefined, (_, element) => f(element));
+function forEach_1(f) {
+  return self => {
+    foldLeft_1(undefined, (_, element) => f(element))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Vector forEachWithIndex
+ * @tsplus pipeable fncts.Vector forEachWithIndex
  */
-
-
-function forEachWithIndex_(as, f) {
-  foldLeftWithIndex_1(as, undefined, (index, _, element) => f(index, element));
+function forEachWithIndex(f) {
+  return self => {
+    foldLeftWithIndex_1(undefined, (index, _, element) => f(index, element))(self);
+  };
 }
 /**
  * Gets the nth element of the Vector. If `n` is out of bounds
  * `undefined` is returned.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector get
+ * @tsplus pipeable fncts.Vector get
  */
-
-
-function get_(self, index) {
-  return tsplus_module_5.fromNullable(unsafeGet_1(self, index));
+function get(index) {
+  return self => {
+    return tsplus_module_5.fromNullable(unsafeGet_1(index)(self));
+  };
 }
 /**
  * Returns a Vector of Vectors where each subvector's elements are pairwise
@@ -723,22 +673,21 @@ function get_(self, index) {
  * equal elements should be grouped together the Vector should be sorted
  * before grouping.
  *
- * @tsplus fluent fncts.Vector groupWith
+ * @tsplus pipeable fncts.Vector groupWith
  */
-
-
-function groupWith_(as, f) {
-  const result = emptyPushable_1();
-  let buffer = emptyPushable_1();
-  forEach_1(as, a => {
-    if (buffer.length !== 0 && !f(unsafeLast_1(buffer), a)) {
-      tsplus_module_2.push(result, buffer);
-      buffer = emptyPushable_1();
-    }
-
-    tsplus_module_2.push(buffer, a);
-  });
-  return buffer.length === 0 ? result : tsplus_module_2.push(result, buffer);
+function groupWith(f) {
+  return self => {
+    const result = emptyPushable_1();
+    let buffer = emptyPushable_1();
+    forEach_1(a => {
+      if (buffer.length !== 0 && !f(unsafeLast_1(buffer), a)) {
+        tsplus_module_2.push(buffer)(result);
+        buffer = emptyPushable_1();
+      }
+      tsplus_module_2.push(a)(buffer);
+    })(self);
+    return buffer.length === 0 ? result : tsplus_module_2.push(buffer)(result);
+  };
 }
 /**
  * Returns the first element of the Vector.
@@ -746,12 +695,9 @@ function groupWith_(as, f) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector head
  */
-
-
 function head(self) {
   return tsplus_module_5.fromNullable(unsafeHead_1(self));
 }
-
 function indexOfCb(value, state) {
   ++state.index;
   return !(state.found = tsplus_module_3.strictEquals(value, state.element));
@@ -761,76 +707,72 @@ function indexOfCb(value, state) {
  * to the given element. If no such element is found `-1` is returned.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector indexOf
- */
-
-
-function indexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: -1
+ * @tsplus pipeable fncts.Vector indexOf
+ */
+function indexOf(element) {
+  return self => {
+    const state = {
+      element,
+      found: false,
+      index: -1
+    };
+    (0, tsplus_module_2.foldLeftCb)(indexOfCb, state, self);
+    return state.found ? state.index : -1;
   };
-  (0, tsplus_module_2.foldLeftCb)(indexOfCb, state, as);
-  return state.found ? state.index : -1;
 }
 /**
  * Inserts the given element at the given index in the Vector.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector insertAt
+ * @tsplus pipeable fncts.Vector insertAt
  */
-
-
-function insertAt_(as, index, element) {
-  return concat_1(append_1(slice_1(as, 0, index), element), slice_1(as, index, as.length));
+function insertAt(index, element) {
+  return self => {
+    return concat_1(slice_1(index, self.length)(self))(append_1(element)(slice_1(0, index)(self)));
+  };
 }
 /**
  * Inserts the given Vector of elements at the given index in the Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector insertAllAt
+ * @tsplus pipeable fncts.Vector insertAllAt
  */
-
-
-function insertAllAt_(as, index, elements) {
-  return concat_1(concat_1(slice_1(as, 0, index), elements), slice_1(as, index, as.length));
+function insertAllAt(index, elements) {
+  return self => {
+    return concat_1(slice_1(index, self.length)(self))(concat_1(elements)(slice_1(0, index)(self)));
+  };
 }
 /**
  * Inserts a separator between each element in a Vector.
  *
- * @tsplus fluent fncts.Vector intersperse
+ * @tsplus pipeable fncts.Vector intersperse
  */
-
-
-function intersperse_(as, separator) {
-  return pop_1(foldLeft_1(as, emptyPushable_1(), (l2, a) => tsplus_module_2.push(tsplus_module_2.push(l2, a), separator)));
+function intersperse(separator) {
+  return self => {
+    return pop_1(foldLeft_1(emptyPushable_1(), (l2, a) => tsplus_module_2.push(separator)(tsplus_module_2.push(a)(l2)))(self));
+  };
 }
 /**
  * @tsplus fluent fncts.Vector isEmpty
  */
-
-
-function isEmpty(l) {
-  return l.length === 0;
+function isEmpty(self) {
+  return self.length === 0;
 }
 /**
  * @tsplus fluent fncts.Vector isNonEmpty
  */
-
-
-function isNonEmpty(l) {
-  return l.length > 0;
+function isNonEmpty(self) {
+  return self.length > 0;
 }
 /**
  * Concatenates the strings in the Vector separated by a specified separator.
  *
- * @tsplus fluent fncts.Vector join
+ * @tsplus pipeable fncts.Vector join
  */
-
-
-function join_(as, separator) {
-  return foldLeft_1(as, "", (a, b) => a.length === 0 ? b : a + separator + b);
+function join(separator) {
+  return self => {
+    return foldLeft_1("", (a, b) => a.length === 0 ? b : a + separator + b)(self);
+  };
 }
 /**
  * Returns the last element of the Vector.
@@ -838,28 +780,26 @@ function join_(as, separator) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector last
  */
-
-
-function last(l) {
-  return tsplus_module_5.fromNullable(unsafeLast_1(l));
+function last(self) {
+  return tsplus_module_5.fromNullable(unsafeLast_1(self));
 }
 /**
  * Returns the index of the _last_ element in the Vector that is equal
  * to the given element. If no such element is found `-1` is returned.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector lastIndexOf
- */
-
-
-function lastIndexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: 0
+ * @tsplus pipeable fncts.Vector lastIndexOf
+ */
+function lastIndexOf(element) {
+  return self => {
+    const state = {
+      element,
+      found: false,
+      index: 0
+    };
+    (0, tsplus_module_2.foldRightCb)(indexOfCb, state, self);
+    return state.found ? self.length - state.index : -1;
   };
-  (0, tsplus_module_2.foldRightCb)(indexOfCb, state, as);
-  return state.found ? as.length - state.index : -1;
 }
 /**
  * Generates a new Vector by calling a function with the current index
@@ -868,60 +808,54 @@ function lastIndexOf_(as, element) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps makeBy
  */
-
-
 function makeBy(n, f) {
   const l = emptyPushable_1();
-
   for (let i = 0; i < n; i++) {
-    tsplus_module_2.push(l, f(i));
+    tsplus_module_2.push(f(i))(l);
   }
-
   return l;
 }
 /**
- * @tsplus fluent fncts.Vector mapAccum
+ * @tsplus pipeable fncts.Vector mapAccum
  */
-
-
-function mapAccum_(fa, s, f) {
-  return foldLeft_1(fa, [emptyPushable_1(), s], ([acc, s], a) => {
-    const r = f(s, a);
-    tsplus_module_2.push(acc, r[0]);
-    return [acc, r[1]];
-  });
+function mapAccum(s, f) {
+  return self => {
+    return foldLeft_1([emptyPushable_1(), s], ([acc, s], a) => {
+      const r = f(s, a);
+      tsplus_module_2.push(r[0])(acc);
+      return [acc, r[1]];
+    })(self);
+  };
 }
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector map
+ * @tsplus pipeable fncts.Vector map
  */
-
-
-function map_1(fa, f) {
-  return mapWithIndex_1(fa, (_, a) => f(a));
+function map_1(f) {
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector mapWithIndex
+ * @tsplus pipeable fncts.Vector mapWithIndex
  */
-
-
-function mapWithIndex_1(fa, f) {
-  return new tsplus_module_1.Vector(fa.bits, fa.offset, fa.length, (0, tsplus_module_2.mapPrefix)(f, fa.prefix, (0, tsplus_module_2.getPrefixSize)(fa)), fa.root === undefined ? undefined : (0, tsplus_module_2.mapNode)(f, fa.root, (0, tsplus_module_2.getDepth)(fa), (0, tsplus_module_2.getPrefixSize)(fa), 1)[0], (0, tsplus_module_2.mapAffix)(f, fa.suffix, (0, tsplus_module_2.getSuffixSize)(fa), fa.length));
+function mapWithIndex_1(f) {
+  return self => {
+    return new tsplus_module_1.Vector(self.bits, self.offset, self.length, (0, tsplus_module_2.mapPrefix)(f, self.prefix, (0, tsplus_module_2.getPrefixSize)(self)), self.root === undefined ? undefined : (0, tsplus_module_2.mapNode)(f, self.root, (0, tsplus_module_2.getDepth)(self), (0, tsplus_module_2.getPrefixSize)(self), 1)[0], (0, tsplus_module_2.mapAffix)(f, self.suffix, (0, tsplus_module_2.getSuffixSize)(self), self.length));
+  };
 }
 /**
  * @tsplus getter fncts.Vector mutableClone
  */
-
-
-function mutableClone_1(as) {
-  return new tsplus_module_1.Vector(as.bits, as.offset, as.length, as.prefix, as.root, as.suffix);
+function mutableClone_1(self) {
+  return new tsplus_module_1.Vector(self.bits, self.offset, self.length, self.prefix, self.root, self.suffix);
 }
 /**
  * Returns a Vector that has the entry specified by the index replaced with
@@ -932,16 +866,15 @@ function mutableClone_1(as) {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector modifyAt
+ * @tsplus pipeable fncts.Vector modifyAt
  */
-
-
-function modifyAt_(as, i, f) {
-  if (i < 0 || as.length <= i) {
-    return as;
-  }
-
-  return updateAt_1(as, i, f(unsafeGet_1(as, i)));
+function modifyAt(i, f) {
+  return self => {
+    if (i < 0 || self.length <= i) {
+      return self;
+    }
+    return updateAt_1(i, f(unsafeGet_1(i)(self)))(self);
+  };
 }
 /**
  * Returns `true` if and only if the predicate function returns
@@ -949,12 +882,12 @@ function modifyAt_(as, i, f) {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector none
+ * @tsplus pipeable fncts.Vector none
  */
-
-
-function none_(as, predicate) {
-  return !exists_1(as, predicate);
+function none(predicate) {
+  return self => {
+    return !some_1(predicate)(self);
+  };
 }
 /**
  * Takes two arguments and returns a Vector that contains them.
@@ -962,8 +895,6 @@ function none_(as, predicate) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps pair
  */
-
-
 function pair(first, second) {
   return new tsplus_module_1.Vector(2, 0, 2, tsplus_module_2.emptyAffix, undefined, [first, second]);
 }
@@ -974,42 +905,37 @@ function pair(first, second) {
  * @complexity `O(1)`
  * @tsplus getter fncts.Vector pop
  */
-
-
-function pop_1(as) {
-  return slice_1(as, 0, -1);
+function pop_1(self) {
+  return slice_1(0, -1)(self);
 }
 /**
  * Prepends an element to the front of a Vector and returns the new Vector.
  *
  * @complexity O(1)
  *
- * @tsplus fluent fncts.Vector prepend
+ * @tsplus pipeable fncts.Vector prepend
  */
-
-
-function prepend_1(as, a) {
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(as);
-
-  if (prefixSize < 32) {
-    return new tsplus_module_1.Vector((0, tsplus_module_2.incrementPrefix)(as.bits), as.offset, as.length + 1, (0, tsplus_module_2.affixPush)(a, as.prefix, prefixSize), as.root, as.suffix);
-  } else {
-    const newVector = mutableClone_1(as);
-    (0, tsplus_module_2.prependNodeToTree)(newVector, (0, tsplus_module_2.reverseArray)(as.prefix));
-    const newPrefix = [a];
-    newVector.prefix = newPrefix;
-    newVector.length++;
-    newVector.bits = (0, tsplus_module_2.setPrefix)(1, newVector.bits);
-    return newVector;
-  }
+function prepend_1(a) {
+  return self => {
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    if (prefixSize < 32) {
+      return new tsplus_module_1.Vector((0, tsplus_module_2.incrementPrefix)(self.bits), self.offset, self.length + 1, (0, tsplus_module_2.affixPush)(a, self.prefix, prefixSize), self.root, self.suffix);
+    } else {
+      const newVector = mutableClone_1(self);
+      (0, tsplus_module_2.prependNodeToTree)(newVector, (0, tsplus_module_2.reverseArray)(self.prefix));
+      const newPrefix = [a];
+      newVector.prefix = newPrefix;
+      newVector.length++;
+      newVector.bits = (0, tsplus_module_2.setPrefix)(1, newVector.bits);
+      return newVector;
+    }
+  };
 }
 /**
  * @tsplus operator fncts.Vector +
  */
-
-
-function prependOperator(a, as) {
-  return prepend_1(as, a);
+function prependOperator(a, self) {
+  return prepend_1(a)(self);
 }
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
@@ -1017,15 +943,11 @@ function prependOperator(a, as) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps range
  */
-
-
 function range(start, end) {
   const vec = emptyPushable_1();
-
   for (let i = start; i < end; ++i) {
-    tsplus_module_2.push(vec, i);
+    tsplus_module_2.push(i)(vec);
   }
-
   return vec;
 }
 /**
@@ -1035,12 +957,12 @@ function range(start, end) {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector remove
+ * @tsplus pipeable fncts.Vector remove
  */
-
-
-function remove_(as, from, amount) {
-  return concat_1(slice_1(as, 0, from), slice_1(as, from + amount, as.length));
+function remove(from, amount) {
+  return self => {
+    return concat_1(slice_1(from + amount, self.length)(self))(slice_1(0, from)(self));
+  };
 }
 /**
  * Returns a Vector of a given length that contains the specified value
@@ -1049,36 +971,30 @@ function remove_(as, from, amount) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps replicate
  */
-
-
 function replicate(n, a) {
   let t = n;
   const l = emptyPushable_1();
-
   while (--t >= 0) {
-    tsplus_module_2.push(l, a);
+    tsplus_module_2.push(a)(l);
   }
-
   return l;
 }
 /**
  * @tsplus getter fncts.Vector reverse
  */
-
-
 function reverse(self) {
-  return foldLeft_1(self, empty_1(), (vec, elem) => prepend_1(vec, elem));
+  return foldLeft_1(empty_1(), (vec, elem) => prepend_1(elem)(vec))(self);
 }
 /**
  * Folds a function over a Vector from left to right while collecting
  * all the intermediate steps in a resulting Vector.
  *
- * @tsplus fluent fncts.Vector scanLeft
+ * @tsplus pipeable fncts.Vector scanLeft
  */
-
-
-function scanLeft_(as, initial, f) {
-  return foldLeft_1(as, tsplus_module_2.push(emptyPushable_1(), initial), (l2, a) => tsplus_module_2.push(l2, f(unsafeLast_1(l2), a)));
+function scanLeft(initial, f) {
+  return self => {
+    return foldLeft_1(tsplus_module_2.push(initial)(emptyPushable_1()), (l2, a) => tsplus_module_2.push(f(unsafeLast_1(l2), a))(l2))(self);
+  };
 }
 /**
  * Takes a single arguments and returns a singleton Vector that contains it.
@@ -1086,8 +1002,6 @@ function scanLeft_(as, initial, f) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps single
  */
-
-
 function single(a) {
   return vector_1(a);
 }
@@ -1097,115 +1011,100 @@ function single(a) {
  * from the right end of the Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector slice
- */
-
-
-function slice_1(as, from, to) {
-  let {
-    bits,
-    length
-  } = as;
-  let _to = to;
-  let _from = from;
-  _to = Math.min(length, to); // Handle negative indices
-
-  if (_from < 0) {
-    _from = length + from;
-  }
-
-  if (_to < 0) {
-    _to = length + to;
-  } // Should we just return the empty Vector?
-
-
-  if (_to <= _from || _to <= 0 || length <= _from) {
-    return empty_1();
-  } // Return Vector unchanged if we are slicing nothing off
-
-
-  if (_from <= 0 && length <= _to) {
-    return as;
-  }
-
-  const newLength = _to - _from;
-  let prefixSize = (0, tsplus_module_2.getPrefixSize)(as);
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(as); // Both indices lie in the prefix
-
-  if (_to <= prefixSize) {
-    return new tsplus_module_1.Vector((0, tsplus_module_2.setPrefix)(newLength, 0), 0, newLength, as.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, tsplus_module_2.emptyAffix);
-  }
-
-  const suffixStart = length - suffixSize; // Both indices lie in the suffix
-
-  if (suffixStart <= _from) {
-    return new tsplus_module_1.Vector((0, tsplus_module_2.setSuffix)(newLength, 0), 0, newLength, tsplus_module_2.emptyAffix, undefined, as.suffix.slice(_from - suffixStart, _to - suffixStart));
-  }
-
-  const newVector = mutableClone_1(as);
-  newVector.length = newLength; // Both indices lie in the tree
-
-  if (prefixSize <= _from && _to <= suffixStart) {
-    (0, tsplus_module_2.sliceTreeVector)(_from - prefixSize + as.offset, _to - prefixSize + as.offset - 1, as.root, (0, tsplus_module_2.getDepth)(as), as.offset, newVector);
-    return newVector;
-  }
-
-  if (0 < _from) {
-    // we need _to slice something off of the left
-    if (_from < prefixSize) {
-      // shorten the prefix even though it's not strictly needed,
-      // so that referenced items can be GC'd
-      newVector.prefix = as.prefix.slice(0, prefixSize - _from);
-      bits = (0, tsplus_module_2.setPrefix)(prefixSize - _from, bits);
-    } else {
-      // if we're here `_to` can't lie in the tree, so we can set the
-      // root
-      (0, tsplus_module_2.zeroOffset)();
-      newVector.root = (0, tsplus_module_2.sliceLeft)(newVector.root, (0, tsplus_module_2.getDepth)(as), _from - prefixSize, as.offset, true);
-      newVector.offset = tsplus_module_2.newOffset;
-
-      if (newVector.root === undefined) {
-        bits = (0, tsplus_module_2.setDepth)(0, bits);
+ * @tsplus pipeable fncts.Vector slice
+ */
+function slice_1(from, to) {
+  return self => {
+    let {
+      bits,
+      length
+    } = self;
+    let _to = to;
+    let _from = from;
+    _to = Math.min(length, to);
+    // Handle negative indices
+    if (_from < 0) {
+      _from = length + from;
+    }
+    if (_to < 0) {
+      _to = length + to;
+    }
+    // Should we just return the empty Vector?
+    if (_to <= _from || _to <= 0 || length <= _from) {
+      return empty_1();
+    }
+    // Return Vector unchanged if we are slicing nothing off
+    if (_from <= 0 && length <= _to) {
+      return self;
+    }
+    const newLength = _to - _from;
+    let prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    // Both indices lie in the prefix
+    if (_to <= prefixSize) {
+      return new tsplus_module_1.Vector((0, tsplus_module_2.setPrefix)(newLength, 0), 0, newLength, self.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, tsplus_module_2.emptyAffix);
+    }
+    const suffixStart = length - suffixSize;
+    // Both indices lie in the suffix
+    if (suffixStart <= _from) {
+      return new tsplus_module_1.Vector((0, tsplus_module_2.setSuffix)(newLength, 0), 0, newLength, tsplus_module_2.emptyAffix, undefined, self.suffix.slice(_from - suffixStart, _to - suffixStart));
+    }
+    const newVector = mutableClone_1(self);
+    newVector.length = newLength;
+    // Both indices lie in the tree
+    if (prefixSize <= _from && _to <= suffixStart) {
+      (0, tsplus_module_2.sliceTreeVector)(_from - prefixSize + self.offset, _to - prefixSize + self.offset - 1, self.root, (0, tsplus_module_2.getDepth)(self), self.offset, newVector);
+      return newVector;
+    }
+    if (0 < _from) {
+      // we need _to slice something off of the left
+      if (_from < prefixSize) {
+        // shorten the prefix even though it's not strictly needed,
+        // so that referenced items can be GC'd
+        newVector.prefix = self.prefix.slice(0, prefixSize - _from);
+        bits = (0, tsplus_module_2.setPrefix)(prefixSize - _from, bits);
+      } else {
+        // if we're here `_to` can't lie in the tree, so we can set the
+        // root
+        (0, tsplus_module_2.zeroOffset)();
+        newVector.root = (0, tsplus_module_2.sliceLeft)(newVector.root, (0, tsplus_module_2.getDepth)(self), _from - prefixSize, self.offset, true);
+        newVector.offset = tsplus_module_2.newOffset;
+        if (newVector.root === undefined) {
+          bits = (0, tsplus_module_2.setDepth)(0, bits);
+        }
+        bits = (0, tsplus_module_2.setPrefix)(tsplus_module_2.newAffix.length, bits);
+        prefixSize = tsplus_module_2.newAffix.length;
+        newVector.prefix = tsplus_module_2.newAffix;
       }
-
-      bits = (0, tsplus_module_2.setPrefix)(tsplus_module_2.newAffix.length, bits);
-      prefixSize = tsplus_module_2.newAffix.length;
-      newVector.prefix = tsplus_module_2.newAffix;
     }
-  }
-
-  if (_to < length) {
-    // we need _to slice something off of the right
-    if (length - _to < suffixSize) {
-      bits = (0, tsplus_module_2.setSuffix)(suffixSize - (length - _to), bits); // slice the suffix even though it's not strictly needed,
-      // _to allow the removed items _to be GC'd
-
-      newVector.suffix = as.suffix.slice(0, suffixSize - (length - _to));
-    } else {
-      newVector.root = (0, tsplus_module_2.sliceRight)(newVector.root, (0, tsplus_module_2.getDepth)(as), _to - prefixSize - 1, newVector.offset);
-
-      if (newVector.root === undefined) {
-        bits = (0, tsplus_module_2.setDepth)(0, bits);
-        newVector.offset = 0;
+    if (_to < length) {
+      // we need _to slice something off of the right
+      if (length - _to < suffixSize) {
+        bits = (0, tsplus_module_2.setSuffix)(suffixSize - (length - _to), bits);
+        // slice the suffix even though it's not strictly needed,
+        // _to allow the removed items _to be GC'd
+        newVector.suffix = self.suffix.slice(0, suffixSize - (length - _to));
+      } else {
+        newVector.root = (0, tsplus_module_2.sliceRight)(newVector.root, (0, tsplus_module_2.getDepth)(self), _to - prefixSize - 1, newVector.offset);
+        if (newVector.root === undefined) {
+          bits = (0, tsplus_module_2.setDepth)(0, bits);
+          newVector.offset = 0;
+        }
+        bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.newAffix.length, bits);
+        newVector.suffix = tsplus_module_2.newAffix;
       }
-
-      bits = (0, tsplus_module_2.setSuffix)(tsplus_module_2.newAffix.length, bits);
-      newVector.suffix = tsplus_module_2.newAffix;
     }
-  }
-
-  newVector.bits = bits;
-  return newVector;
+    newVector.bits = bits;
+    return newVector;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector sort
+ * @tsplus pipeable fncts.Vector sort
  */
-
-
-function sort_(self,
-/** @tsplus auto */
-O) {
-  return sortWith_1(self, O.compare);
+function sort( /** @tsplus auto */O) {
+  return self => {
+    return sortWith_1((a, b) => O.compare(b)(a))(self);
+  };
 }
 /**
  * Sort the given Vector by comparing values using the given function.
@@ -1216,34 +1115,32 @@ O) {
  *
  * @complexity O(n * log(n))
  *
- * @tsplus fluent fncts.Vector sortWith
- */
-
-
-function sortWith_1(as, compare) {
-  const arr = [];
-  let i = 0;
-  forEach_1(as, elm => arr.push({
-    idx: i++,
-    elm
-  }));
-  arr.sort(({
-    elm: a,
-    idx: i
-  }, {
-    elm: b,
-    idx: j
-  }) => {
-    const c = compare(a, b);
-    return c !== 0 ? c : i < j ? -1 : 1;
-  });
-  const newL = emptyPushable_1();
-
-  for (let i = 0; i < arr.length; ++i) {
-    tsplus_module_2.push(newL, arr[i].elm);
-  }
-
-  return newL;
+ * @tsplus pipeable fncts.Vector sortWith
+ */
+function sortWith_1(compare) {
+  return self => {
+    const arr = [];
+    let i = 0;
+    forEach_1(elm => arr.push({
+      idx: i++,
+      elm
+    }))(self);
+    arr.sort(({
+      elm: a,
+      idx: i
+    }, {
+      elm: b,
+      idx: j
+    }) => {
+      const c = compare(a, b);
+      return c !== 0 ? c : i < j ? -1 : 1;
+    });
+    const newL = emptyPushable_1();
+    for (let i = 0; i < arr.length; ++i) {
+      tsplus_module_2.push(arr[i].elm)(newL);
+    }
+    return newL;
+  };
 }
 /**
  * Splits a Vector at the given index and return the two sides in a pair.
@@ -1253,12 +1150,12 @@ function sortWith_1(as, compare) {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector splitAt
+ * @tsplus pipeable fncts.Vector splitAt
  */
-
-
-function splitAt_1(as, index) {
-  return [slice_1(as, 0, index), slice_1(as, index, as.length)];
+function splitAt_1(index) {
+  return self => {
+    return [slice_1(0, index)(self), slice_1(index, self.length)(self)];
+  };
 }
 /**
  * Splits a Vector at the first element in the Vector for which the given
@@ -1266,13 +1163,13 @@ function splitAt_1(as, index) {
  *
  * @complexity `O(n)`
  *
- * @tsplus fluent fncts.Vector splitWhen
+ * @tsplus pipeable fncts.Vector splitWhen
  */
-
-
-function splitWhen_(as, predicate) {
-  const idx = findIndex_1(as, predicate);
-  return idx === -1 ? [as, empty_1()] : splitAt_1(as, idx);
+function splitWhen(predicate) {
+  return self => {
+    const idx = findIndex_1(predicate)(self);
+    return idx === -1 ? [self, empty_1()] : splitAt_1(idx)(self);
+  };
 }
 /**
  * Returns a new Vector with the first element removed. If the Vector is
@@ -1282,21 +1179,19 @@ function splitWhen_(as, predicate) {
  *
  * @tsplus getter fncts.Vector tail
  */
-
-
-function tail(as) {
-  return slice_1(as, 1, as.length);
+function tail(self) {
+  return slice_1(1, self.length)(self);
 }
 /**
  * Takes the first `n` elements from a Vector and returns them in a new Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector take
+ * @tsplus pipeable fncts.Vector take
  */
-
-
-function take_(as, n) {
-  return slice_1(as, 0, n);
+function take(n) {
+  return self => {
+    return slice_1(0, n)(self);
+  };
 }
 /**
  * Takes the first elements in the Vector for which the predicate returns
@@ -1305,30 +1200,30 @@ function take_(as, n) {
  * @complexity `O(k + log(n))` where `k` is the number of elements satisfying
  * the predicate.
  *
- * @tsplus fluent fncts.Vector takeWhile
- */
-
-
-function takeWhile_(as, predicate) {
-  const {
-    index
-  } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, 0, index);
+ * @tsplus pipeable fncts.Vector takeWhile
+ */
+function takeWhile(predicate) {
+  return self => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, self);
+    return slice_1(0, index)(self);
+  };
 }
 /**
  * Takes the last `n` elements from a Vector and returns them in a new
  * Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector takeLast
+ * @tsplus pipeable fncts.Vector takeLast
  */
-
-
-function takeLast_(as, n) {
-  return slice_1(as, as.length - n, as.length);
+function takeLast(n) {
+  return self => {
+    return slice_1(self.length - n, self.length)(self);
+  };
 }
 /**
  * Takes the last elements in the Vector for which the predicate returns
@@ -1337,18 +1232,18 @@ function takeLast_(as, n) {
  * @complexity `O(k + log(n))` where `k` is the number of elements
  * satisfying the predicate.
  *
- * @tsplus fluent fncts.Vector takeLastWhile
- */
-
-
-function takeLastWhile_(as, predicate) {
-  const {
-    index
-  } = (0, tsplus_module_2.foldRightCb)(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, as.length - index, as.length);
+ * @tsplus pipeable fncts.Vector takeLastWhile
+ */
+function takeLastWhile(predicate) {
+  return self => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldRightCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, self);
+    return slice_1(self.length - index, self.length)(self);
+  };
 }
 /**
  * Converts a Vector into an array.
@@ -1356,10 +1251,8 @@ function takeLastWhile_(as, predicate) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector toArray
  */
-
-
 function toArray(self) {
-  return foldLeft_1(self, [], tsplus_module_2.arrayPush);
+  return foldLeft_1([], tsplus_module_2.arrayPush)(self);
 }
 /**
  * Converts a Vector into a List.
@@ -1367,72 +1260,58 @@ function toArray(self) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector toList
  */
-
-
 function toList(self) {
   const buffer = new tsplus_module_6.ListBuffer();
-  forEach_1(self, a => {
+  forEach_1(a => {
     buffer.append(a);
-  });
+  })(self);
   return buffer.toList;
 }
-/**
- * @tsplus getter fncts.Vector traverseWithIndex
- */
-
-
-const traverseWithIndex_1 = /*#__PURE__*/tsplus_module_7.mkTraverseWithIndex_()(() => self => G => f => {
-  return foldLeftWithIndex_1(self, G.pure(emptyPushable_1()), (i, b, a) => G.zipWith(b, f(i, a), (v, b) => {
-    (0, tsplus_module_2.push)(v, b);
+function _traverseWithIndex_1(self) {
+  return G => f => foldLeftWithIndex_1(G.pure(emptyPushable_1()), (i, b, a) => G.zipWith(f(i, a), (v, b) => {
+    tsplus_module_2.push(b)(v);
     return v;
-  }));
-});
-const traverseWithIndex = traverseWithIndex_1;
+  })(b))(self);
+}
 /**
  * @tsplus getter fncts.Vector traverse
  */
-
+function _traverse(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
 exports.traverseWithIndex = traverseWithIndex;
-
-const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
  *
  * @complexity `O(n)`
- * @tsplus getter fncts.Vector uniq
+ * @tsplus pipeable fncts.Vector uniq
  */
-
-
 exports.traverse = traverse;
-
-function uniq(as) {
-  return E => dropRepeatsWith_1(as, E.equals);
+function uniq(E) {
+  return self => dropRepeatsWith_1((a, b) => E.equals(b)(a))(self);
 }
 /**
  * @tsplus static fncts.VectorOps unfold
  */
-
-
 function unfold(b, f) {
   const out = emptyPushable_1();
-  let state = b; // eslint-disable-next-line no-constant-condition
-
+  let state = b;
+  // eslint-disable-next-line no-constant-condition
   while (true) {
     const mt = f(state);
-
-    if (tsplus_module_8.isJust(mt)) {
+    if (tsplus_module_7.isJust(mt)) {
       const [a, b] = mt.value;
-      tsplus_module_2.push(out, a);
+      tsplus_module_2.push(a)(out);
       state = b;
     } else {
       break;
     }
   }
-
   return out;
 }
-
 function findCb(value, state) {
   if (state.predicate(value)) {
     state.result = value;
@@ -1446,59 +1325,57 @@ function findCb(value, state) {
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFind
- */
-
-
-function unsafeFind_1(as, predicate) {
-  return (0, tsplus_module_2.foldLeftCb)(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+ * @tsplus pipeable fncts.Vector unsafeFind
+ */
+function unsafeFind_1(predicate) {
+  return self => {
+    return (0, tsplus_module_2.foldLeftCb)(findCb, {
+      predicate,
+      result: undefined
+    }, self).result;
+  };
 }
 /**
  * Returns the _last_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFindLast
- */
-
-
-function unsafeFindLast_1(as, predicate) {
-  return (0, tsplus_module_2.foldRightCb)(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+ * @tsplus pipeable fncts.Vector unsafeFindLast
+ */
+function unsafeFindLast_1(predicate) {
+  return self => {
+    return (0, tsplus_module_2.foldRightCb)(findCb, {
+      predicate,
+      result: undefined
+    }, self).result;
+  };
 }
 /**
  * Gets the nth element of the Vector. If `n` is out of bounds
  * `undefined` is returned.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector unsafeGet
+ * @tsplus pipeable fncts.Vector unsafeGet
+ * @tsplus pipeable-index fncts.Vector
  */
-
-
-function unsafeGet_1(l, index) {
-  if (index < 0 || l.length <= index) {
-    return undefined;
-  }
-
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(l);
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(l);
-
-  if (index < prefixSize) {
-    return l.prefix[prefixSize - index - 1];
-  } else if (index >= l.length - suffixSize) {
-    return l.suffix[index - (l.length - suffixSize)];
-  }
-
-  const {
-    offset
-  } = l;
-  const depth = (0, tsplus_module_2.getDepth)(l);
-  return l.root.sizes === undefined ? (0, tsplus_module_2.nodeNthDense)(l.root, depth, offset === 0 ? index - prefixSize : (0, tsplus_module_2.handleOffset)(depth, offset, index - prefixSize)) : (0, tsplus_module_2.nodeNth)(l.root, depth, offset, index - prefixSize);
+function unsafeGet_1(index) {
+  return self => {
+    if (index < 0 || self.length <= index) {
+      return undefined;
+    }
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    if (index < prefixSize) {
+      return self.prefix[prefixSize - index - 1];
+    } else if (index >= self.length - suffixSize) {
+      return self.suffix[index - (self.length - suffixSize)];
+    }
+    const {
+      offset
+    } = self;
+    const depth = (0, tsplus_module_2.getDepth)(self);
+    return self.root.sizes === undefined ? (0, tsplus_module_2.nodeNthDense)(self.root, depth, offset === 0 ? index - prefixSize : (0, tsplus_module_2.handleOffset)(depth, offset, index - prefixSize)) : (0, tsplus_module_2.nodeNth)(self.root, depth, offset, index - prefixSize);
+  };
 }
 /**
  * Returns the first element of the Vector. If the Vector is empty the
@@ -1507,11 +1384,9 @@ function unsafeGet_1(l, index) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeHead
  */
-
-
-function unsafeHead_1(l) {
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(l);
-  return prefixSize !== 0 ? l.prefix[prefixSize - 1] : l.length !== 0 ? l.suffix[0] : undefined;
+function unsafeHead_1(self) {
+  const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+  return prefixSize !== 0 ? self.prefix[prefixSize - 1] : self.length !== 0 ? self.suffix[0] : undefined;
 }
 /**
  * Returns the last element of the Vector. If the Vector is empty the
@@ -1520,11 +1395,9 @@ function unsafeHead_1(l) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeLast
  */
-
-
-function unsafeLast_1(l) {
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(l);
-  return suffixSize !== 0 ? l.suffix[suffixSize - 1] : l.length !== 0 ? l.prefix[0] : undefined;
+function unsafeLast_1(self) {
+  const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+  return suffixSize !== 0 ? self.suffix[suffixSize - 1] : self.length !== 0 ? self.prefix[0] : undefined;
 }
 /**
  * Returns a Vector that has the entry specified by the index replaced with the given value.
@@ -1532,45 +1405,38 @@ function unsafeLast_1(l) {
  * If the index is out of bounds the given Vector is returned unchanged.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector updateAt
+ * @tsplus pipeable fncts.Vector updateAt
  */
-
-
-function updateAt_1(as, i, a) {
-  if (i < 0 || as.length <= i) {
-    return as;
-  }
-
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(as);
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(as);
-  const newVector = mutableClone_1(as);
-
-  if (i < prefixSize) {
-    const newPrefix = (0, tsplus_module_2.copyArray)(newVector.prefix);
-    newPrefix[newPrefix.length - i - 1] = a;
-    newVector.prefix = newPrefix;
-  } else if (i >= as.length - suffixSize) {
-    const newSuffix = (0, tsplus_module_2.copyArray)(newVector.suffix);
-    newSuffix[i - (as.length - suffixSize)] = a;
-    newVector.suffix = newSuffix;
-  } else {
-    newVector.root = (0, tsplus_module_2.updateNode)(as.root, (0, tsplus_module_2.getDepth)(as), i - prefixSize, as.offset, a);
-  }
-
-  return newVector;
+function updateAt_1(i, a) {
+  return self => {
+    if (i < 0 || self.length <= i) {
+      return self;
+    }
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(self);
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(self);
+    const newVector = mutableClone_1(self);
+    if (i < prefixSize) {
+      const newPrefix = (0, tsplus_module_2.copyArray)(newVector.prefix);
+      newPrefix[newPrefix.length - i - 1] = a;
+      newVector.prefix = newPrefix;
+    } else if (i >= self.length - suffixSize) {
+      const newSuffix = (0, tsplus_module_2.copyArray)(newVector.suffix);
+      newSuffix[i - (self.length - suffixSize)] = a;
+      newVector.suffix = newSuffix;
+    } else {
+      newVector.root = (0, tsplus_module_2.updateNode)(self.root, (0, tsplus_module_2.getDepth)(self), i - prefixSize, self.offset, a);
+    }
+    return newVector;
+  };
 }
 /**
  * @tsplus static fncts.VectorOps __call
  */
-
-
 function vector_1(...elements) {
   const v = emptyPushable_1();
-
   for (const element of elements) {
-    tsplus_module_2.push(v, element);
+    tsplus_module_2.push(element)(v);
   }
-
   return v;
 }
 //# sourceMappingURL=api.cjs.map