@fncts/base 0.0.19 → 0.0.21

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

@@ -3,77 +3,79 @@
 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.exists = void 0;
+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.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"));
 
@@ -87,68 +89,68 @@ var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require
 
 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 exists = exists_1;
+exports.exists = exists;
+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;
 
@@ -157,116 +159,124 @@ exports.vector = 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);
+function append_1(a) {
+  return as => {
+    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));
-  }
+    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;
+    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;
+  };
 }
 /**
  * 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 ma => {
+    return flatten_1(map_1(f)(ma));
+  };
 }
 /**
  * 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);
+ * @tsplus pipeable fncts.Vector chunksOf
+ */
+
+
+function chunksOf(size) {
+  return as => {
+    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
+        };
+      }
+    })(as);
+    return buffer.length === 0 ? l2 : tsplus_module_2.push(buffer)(l2);
+  };
+}
 
-    if (buffer.length === size) {
-      return {
-        l2: tsplus_module_2.push(l2, buffer),
-        buffer: emptyPushable_1()
-      };
-    } else {
-      return {
-        l2,
-        buffer
-      };
+function concat_1(that) {
+  return self => {
+    if (self.length === 0) {
+      return that;
+    } else if (that.length === 0) {
+      return self;
     }
-  });
-  return buffer.length === 0 ? l2 : tsplus_module_2.push(l2, buffer);
-}
 
-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);
 
-  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);
 
-  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
 
-    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;
+      }
 
-      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);
 
-    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;
+      }
 
-    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 = {
@@ -282,36 +292,42 @@ 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 as => {
+    containsState.element = element;
+    containsState.result = false;
+    return (0, tsplus_module_2.foldLeftCb)(containsCb, containsState, as).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 as => {
+    return slice_1(n, as.length)(as);
+  };
 }
 /**
  * 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 as => {
+    return slice_1(0, as.length - n)(as);
+  };
 }
 /**
  * Returns a new Vector without repeated elements.
@@ -322,19 +338,21 @@ function dropLast_(as, n) {
 
 
 function dropRepeats(as) {
-  return dropRepeatsWith_1(as, tsplus_module_3.strictEquals);
+  return dropRepeatsWith_1(tsplus_module_3.strictEquals)(as);
 }
 /**
  * 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 as => {
+    return foldLeft_1(emptyPushable_1(), (acc, a) => acc.length !== 0 && predicate(unsafeLast_1(acc), a) ? acc : tsplus_module_2.push(a)(acc))(as);
+  };
 }
 
 function findNotIndexCb(value, state) {
@@ -351,62 +369,68 @@ function findNotIndexCb(value, state) {
  *
  * @complexity `O(k + log(n))` where `k` is the number of elements
  * satisfying the predicate.
- * @tsplus fluent fncts.Vector dropWhile
+ * @tsplus pipeable 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);
+function dropWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, as);
+    return slice_1(index, as.length)(as);
+  };
 }
 
 function elemCb(value, state) {
   return !(state.result = state.equals(value, state.element));
 }
 /**
- * @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 as => {
+    return (0, tsplus_module_2.foldLeftCb)(everyCb, {
+      predicate,
+      result: true
+    }, as).result;
+  };
 }
 /**
  * Creates an empty Vector.
@@ -437,27 +461,31 @@ function existsCb(value, state) {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector exists
+ * @tsplus pipeable fncts.Vector exists
  */
 
 
-function exists_1(as, predicate) {
-  return (0, tsplus_module_2.foldLeftCb)(existsCb, {
-    predicate,
-    result: false
-  }, as).result;
+function exists_1(predicate) {
+  return as => {
+    return (0, tsplus_module_2.foldLeftCb)(existsCb, {
+      predicate,
+      result: false
+    }, as).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 as => {
+    return tsplus_module_5.fromNullable(unsafeFind_1(predicate)(as));
+  };
 }
 
 function findIndexCb(value, state) {
@@ -470,32 +498,36 @@ function findIndexCb(value, state) {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findIndex
+ * @tsplus pipeable 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;
+function findIndex_1(predicate) {
+  return as => {
+    const {
+      found,
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findIndexCb, {
+      predicate,
+      found: false,
+      index: -1
+    }, as);
+    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 as => {
+    return tsplus_module_5.fromNullable(unsafeFindLast_1(predicate)(as));
+  };
 }
 /**
  * Returns the index of the `last` element for which the predicate
@@ -503,20 +535,22 @@ function findLast_(as, predicate) {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLastIndex
+ * @tsplus pipeable 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;
+function findLastIndex(predicate) {
+  return as => {
+    const {
+      found,
+      index
+    } = (0, tsplus_module_2.foldRightCb)(findIndexCb, {
+      predicate,
+      found: false,
+      index: -0
+    }, as);
+    return found ? index : -1;
+  };
 }
 /**
  * Flattens a Vector of Vectors into a Vector. Note that this function does
@@ -529,7 +563,7 @@ function findLastIndex_(as, predicate) {
 
 
 function flatten_1(mma) {
-  return foldLeft_1(mma, empty_1(), (acc, a) => concat_1(acc, a));
+  return foldLeft_1(empty_1(), (acc, a) => concat_1(a)(acc))(mma);
 }
 
 function from(sequence) {
@@ -537,14 +571,14 @@ function from(sequence) {
 
   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);
     }
   }
 
@@ -553,28 +587,32 @@ function from(sequence) {
 /**
  * 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 fa => {
+    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  };
 }
 /**
- * @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);
+function foldLeftWithIndex_1(b, f) {
+  return fa => {
+    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);
-  }
+    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];
+    return (0, tsplus_module_2.foldLeftSuffix)(f, acc, fa.suffix, suffixSize, index)[0];
+  };
 }
 /**
  * Similar to `foldl`. But, for each element it calls the predicate function
@@ -601,82 +639,94 @@ function foldWhileCb(a, state, i) {
   return true;
 }
 /**
- * @tsplus fluent fncts.Vector foldLeftWhile
+ * @tsplus pipeable fncts.Vector foldLeftWhile
  */
 
 
-function foldLeftWhile_(fa, b, cont, f) {
-  if (!cont(b)) {
-    return b;
-  }
+function foldLeftWhile(b, cont, f) {
+  return fa => {
+    if (!cont(b)) {
+      return b;
+    }
 
-  return (0, tsplus_module_2.foldLeftCb)(foldWhileCb, {
-    predicate: cont,
-    f,
-    result: b
-  }, fa).result;
+    return (0, tsplus_module_2.foldLeftCb)(foldWhileCb, {
+      predicate: cont,
+      f,
+      result: b
+    }, fa).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 fa => {
+    return (0, tsplus_module_2.foldRightCb)(foldWhileCb, {
+      predicate: cont,
+      result: b,
+      f: (i, b, a) => f(i, a, b)
+    }, fa).result;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldMap
+ * @tsplus pipeable fncts.Vector foldMap
  */
 
 
-function foldMap_(self, f,
+function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldMapWithIndex
+ * @tsplus pipeable fncts.Vector foldMapWithIndex
  */
 
 
-function foldMapWithIndex_1(self, f,
+function foldMapWithIndex_1(f,
 /** @tsplus auto */
 M) {
-  return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine(b, f(i, a)));
+  return self => {
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(b, f(i, a)))(self);
+  };
 }
 /**
  * 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 fa => {
+    return foldRightWithIndex_1(initial, (_, a, b) => f(a, b))(fa);
+  };
 }
 /**
  * Folds a function over a Vector. Right-associative.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRightWithIndex
+ * @tsplus pipeable 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);
+function foldRightWithIndex_1(b, f) {
+  return fa => {
+    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);
-  }
+    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];
+    return (0, tsplus_module_2.foldRightPrefix)(f, acc, fa.prefix, prefixSize, j)[0];
+  };
 }
 /**
  * Invokes a given callback for each element in the Vector from left to
@@ -688,32 +738,38 @@ 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 as => {
+    foldLeft_1(undefined, (_, element) => f(element))(as);
+  };
 }
 /**
- * @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 as => {
+    foldLeftWithIndex_1(undefined, (index, _, element) => f(index, element))(as);
+  };
 }
 /**
  * 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 +779,24 @@ 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();
-    }
+function groupWith(f) {
+  return as => {
+    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(buffer, a);
-  });
-  return buffer.length === 0 ? result : tsplus_module_2.push(result, buffer);
+      tsplus_module_2.push(a)(buffer);
+    })(as);
+    return buffer.length === 0 ? result : tsplus_module_2.push(buffer)(result);
+  };
 }
 /**
  * Returns the first element of the Vector.
@@ -761,50 +819,58 @@ 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
+ * @tsplus pipeable fncts.Vector indexOf
  */
 
 
-function indexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: -1
+function indexOf(element) {
+  return as => {
+    const state = {
+      element,
+      found: false,
+      index: -1
+    };
+    (0, tsplus_module_2.foldLeftCb)(indexOfCb, state, as);
+    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 as => {
+    return concat_1(slice_1(index, as.length)(as))(append_1(element)(slice_1(0, index)(as)));
+  };
 }
 /**
  * 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 as => {
+    return concat_1(slice_1(index, as.length)(as))(concat_1(elements)(slice_1(0, index)(as)));
+  };
 }
 /**
  * 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 as => {
+    return pop_1(foldLeft_1(emptyPushable_1(), (l2, a) => tsplus_module_2.push(separator)(tsplus_module_2.push(a)(l2)))(as));
+  };
 }
 /**
  * @tsplus fluent fncts.Vector isEmpty
@@ -825,12 +891,14 @@ function isNonEmpty(l) {
 /**
  * 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 as => {
+    return foldLeft_1("", (a, b) => a.length === 0 ? b : a + separator + b)(as);
+  };
 }
 /**
  * Returns the last element of the Vector.
@@ -848,18 +916,20 @@ function last(l) {
  * to the given element. If no such element is found `-1` is returned.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector lastIndexOf
+ * @tsplus pipeable fncts.Vector lastIndexOf
  */
 
 
-function lastIndexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: 0
+function lastIndexOf(element) {
+  return as => {
+    const state = {
+      element,
+      found: false,
+      index: 0
+    };
+    (0, tsplus_module_2.foldRightCb)(indexOfCb, state, as);
+    return state.found ? as.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
@@ -874,46 +944,52 @@ 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 fa => {
+    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]];
+    })(fa);
+  };
 }
 /**
  * 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 fa => {
+    return mapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
  * 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 fa => {
+    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));
+  };
 }
 /**
  * @tsplus getter fncts.Vector mutableClone
@@ -932,16 +1008,18 @@ 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;
-  }
+function modifyAt(i, f) {
+  return as => {
+    if (i < 0 || as.length <= i) {
+      return as;
+    }
 
-  return updateAt_1(as, i, f(unsafeGet_1(as, i)));
+    return updateAt_1(i, f(unsafeGet_1(i)(as)))(as);
+  };
 }
 /**
  * Returns `true` if and only if the predicate function returns
@@ -949,12 +1027,14 @@ 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 as => {
+    return !exists_1(predicate)(as);
+  };
 }
 /**
  * Takes two arguments and returns a Vector that contains them.
@@ -977,31 +1057,33 @@ function pair(first, second) {
 
 
 function pop_1(as) {
-  return slice_1(as, 0, -1);
+  return slice_1(0, -1)(as);
 }
 /**
  * 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);
+function prepend_1(a) {
+  return as => {
+    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;
-  }
+    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;
+    }
+  };
 }
 /**
  * @tsplus operator fncts.Vector +
@@ -1009,7 +1091,7 @@ function prepend_1(as, a) {
 
 
 function prependOperator(a, as) {
-  return prepend_1(as, a);
+  return prepend_1(a)(as);
 }
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
@@ -1023,7 +1105,7 @@ 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 +1117,14 @@ 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 as => {
+    return concat_1(slice_1(from + amount, as.length)(as))(slice_1(0, from)(as));
+  };
 }
 /**
  * Returns a Vector of a given length that contains the specified value
@@ -1056,7 +1140,7 @@ function replicate(n, a) {
   const l = emptyPushable_1();
 
   while (--t >= 0) {
-    tsplus_module_2.push(l, a);
+    tsplus_module_2.push(a)(l);
   }
 
   return l;
@@ -1067,18 +1151,20 @@ function replicate(n, a) {
 
 
 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 as => {
+    return foldLeft_1(tsplus_module_2.push(initial)(emptyPushable_1()), (l2, a) => tsplus_module_2.push(f(unsafeLast_1(l2), a))(l2))(as);
+  };
 }
 /**
  * Takes a single arguments and returns a singleton Vector that contains it.
@@ -1097,115 +1183,119 @@ function single(a) {
  * from the right end of the Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector slice
+ * @tsplus pipeable 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
+function slice_1(from, to) {
+  return as => {
+    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 (_from < 0) {
+      _from = length + from;
+    }
 
-  if (_to < 0) {
-    _to = length + to;
-  } // Should we just return the empty Vector?
+    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 (_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;
-  }
+    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
+    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);
-  }
+    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
+    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));
-  }
+    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
+    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 (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);
+    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);
+        }
+
+        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
+    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);
+        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 (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,
+function sort(
 /** @tsplus auto */
 O) {
-  return sortWith_1(self, O.compare);
+  return self => {
+    return sortWith_1(O.compare)(self);
+  };
 }
 /**
  * Sort the given Vector by comparing values using the given function.
@@ -1216,34 +1306,36 @@ 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);
-  }
+ * @tsplus pipeable fncts.Vector sortWith
+ */
+
+
+function sortWith_1(compare) {
+  return as => {
+    const arr = [];
+    let i = 0;
+    forEach_1(elm => arr.push({
+      idx: i++,
+      elm
+    }))(as);
+    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;
+    return newL;
+  };
 }
 /**
  * Splits a Vector at the given index and return the two sides in a pair.
@@ -1253,12 +1345,14 @@ 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 as => {
+    return [slice_1(0, index)(as), slice_1(index, as.length)(as)];
+  };
 }
 /**
  * Splits a Vector at the first element in the Vector for which the given
@@ -1266,13 +1360,15 @@ 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 as => {
+    const idx = findIndex_1(predicate)(as);
+    return idx === -1 ? [as, empty_1()] : splitAt_1(idx)(as);
+  };
 }
 /**
  * Returns a new Vector with the first element removed. If the Vector is
@@ -1285,18 +1381,20 @@ function splitWhen_(as, predicate) {
 
 
 function tail(as) {
-  return slice_1(as, 1, as.length);
+  return slice_1(1, as.length)(as);
 }
 /**
  * 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 as => {
+    return slice_1(0, n)(as);
+  };
 }
 /**
  * Takes the first elements in the Vector for which the predicate returns
@@ -1305,30 +1403,34 @@ function take_(as, n) {
  * @complexity `O(k + log(n))` where `k` is the number of elements satisfying
  * the predicate.
  *
- * @tsplus fluent fncts.Vector takeWhile
+ * @tsplus pipeable 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);
+function takeWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldLeftCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, as);
+    return slice_1(0, index)(as);
+  };
 }
 /**
  * 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 as => {
+    return slice_1(as.length - n, as.length)(as);
+  };
 }
 /**
  * Takes the last elements in the Vector for which the predicate returns
@@ -1337,18 +1439,20 @@ function takeLast_(as, n) {
  * @complexity `O(k + log(n))` where `k` is the number of elements
  * satisfying the predicate.
  *
- * @tsplus fluent fncts.Vector takeLastWhile
+ * @tsplus pipeable 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);
+function takeLastWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = (0, tsplus_module_2.foldRightCb)(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, as);
+    return slice_1(as.length - index, as.length)(as);
+  };
 }
 /**
  * Converts a Vector into an array.
@@ -1359,7 +1463,7 @@ function takeLastWhile_(as, predicate) {
 
 
 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.
@@ -1371,30 +1475,32 @@ function toArray(self) {
 
 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
@@ -1407,7 +1513,7 @@ const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
 exports.traverse = traverse;
 
 function uniq(as) {
-  return E => dropRepeatsWith_1(as, E.equals);
+  return E => dropRepeatsWith_1(E.equals)(as);
 }
 /**
  * @tsplus static fncts.VectorOps unfold
@@ -1421,9 +1527,9 @@ function unfold(b, f) {
   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;
@@ -1446,59 +1552,66 @@ function findCb(value, state) {
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFind
+ * @tsplus pipeable fncts.Vector unsafeFind
  */
 
 
-function unsafeFind_1(as, predicate) {
-  return (0, tsplus_module_2.foldLeftCb)(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+function unsafeFind_1(predicate) {
+  return as => {
+    return (0, tsplus_module_2.foldLeftCb)(findCb, {
+      predicate,
+      result: undefined
+    }, as).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
+ * @tsplus pipeable fncts.Vector unsafeFindLast
  */
 
 
-function unsafeFindLast_1(as, predicate) {
-  return (0, tsplus_module_2.foldRightCb)(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+function unsafeFindLast_1(predicate) {
+  return as => {
+    return (0, tsplus_module_2.foldRightCb)(findCb, {
+      predicate,
+      result: undefined
+    }, as).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;
-  }
+function unsafeGet_1(index) {
+  return l => {
+    if (index < 0 || l.length <= index) {
+      return undefined;
+    }
 
-  const prefixSize = (0, tsplus_module_2.getPrefixSize)(l);
-  const suffixSize = (0, tsplus_module_2.getSuffixSize)(l);
+    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)];
-  }
+    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);
+    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);
+  };
 }
 /**
  * Returns the first element of the Vector. If the Vector is empty the
@@ -1532,32 +1645,34 @@ 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;
-  }
+function updateAt_1(i, a) {
+  return as => {
+    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);
-  }
+    const prefixSize = (0, tsplus_module_2.getPrefixSize)(as);
+    const suffixSize = (0, tsplus_module_2.getSuffixSize)(as);
+    const newVector = mutableClone_1(as);
 
-  return newVector;
+    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;
+  };
 }
 /**
  * @tsplus static fncts.VectorOps __call
@@ -1568,7 +1683,7 @@ 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;