@fncts/base 0.0.20 → 0.0.21

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

@@ -4,152 +4,160 @@ import * as tsplus_module_3 from "@fncts/base/typeclass/Equatable/api";
 import * as tsplus_module_4 from "@fncts/base/collection/immutable/Vector/definition";
 import * as tsplus_module_5 from "@fncts/base/data/Maybe/constructors";
 import * as tsplus_module_6 from "@fncts/base/collection/mutable/ListBuffer";
-import * as tsplus_module_7 from "@fncts/base/typeclass/TraversableWithIndex";
-import * as tsplus_module_8 from "@fncts/base/data/Maybe/definition";
-export const append_ = append_1;
-export const concat_ = concat_1;
-export const dropRepeatsWith_ = dropRepeatsWith_1;
+import * as tsplus_module_7 from "@fncts/base/data/Maybe/definition";
+export const append = append_1;
+export const concat = concat_1;
+export const dropRepeatsWith = dropRepeatsWith_1;
 export const empty = empty_1;
 export const emptyPushable = emptyPushable_1;
-export const exists_ = exists_1;
-export const findIndex_ = findIndex_1;
+export const exists = exists_1;
+export const findIndex = findIndex_1;
 export const flatten = flatten_1;
-export const foldLeft_ = foldLeft_1;
-export const foldLeftWithIndex_ = foldLeftWithIndex_1;
-export const foldMapWithIndex_ = foldMapWithIndex_1;
-export const foldRightWithIndex_ = foldRightWithIndex_1;
-export const forEach_ = forEach_1;
-export const map_ = map_1;
-export const mapWithIndex_ = mapWithIndex_1;
+export const foldLeft = foldLeft_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
+export const forEach = forEach_1;
+export const map = map_1;
+export const mapWithIndex = mapWithIndex_1;
 export const mutableClone = mutableClone_1;
 export const pop = pop_1;
-export const prepend_ = prepend_1;
-export const slice_ = slice_1;
-export const sortWith_ = sortWith_1;
-export const splitAt_ = splitAt_1;
-export const unsafeFind_ = unsafeFind_1;
-export const unsafeFindLast_ = unsafeFindLast_1;
-export const unsafeGet_ = unsafeGet_1;
+export const prepend = prepend_1;
+export const slice = slice_1;
+export const sortWith = sortWith_1;
+export const splitAt = splitAt_1;
+export const _traverseWithIndex = _traverseWithIndex_1;
+export const unsafeFind = unsafeFind_1;
+export const unsafeFindLast = unsafeFindLast_1;
+export const unsafeGet = unsafeGet_1;
 export const unsafeHead = unsafeHead_1;
 export const unsafeLast = unsafeLast_1;
-export const updateAt_ = updateAt_1;
+export const updateAt = updateAt_1;
 export const vector = vector_1;
-import { affixPush, appendNodeToTree, arrayPush, branchBits, concatAffixes, concatBuffer, concatSubTree, copyArray, emptyAffix, foldLeftCb, foldLeftNode, foldLeftPrefix, foldLeftSuffix, foldRightCb, foldRightNode, foldRightPrefix, foldRightSuffix, getDepth, getHeight, getPrefixSize, getSuffixSize, handleOffset, incrementPrefix, incrementSuffix, mapAffix, mapNode, mapPrefix, mask, newAffix, newOffset, nodeNth, nodeNthDense, prependNodeToTree, push, reverseArray, setDepth, setPrefix, setSizes, setSuffix, sliceLeft, sliceRight, sliceTreeVector, updateNode, zeroOffset } from "@fncts/base/collection/immutable/Vector/internal";
+import { affixPush, appendNodeToTree, arrayPush, branchBits, concatAffixes, concatBuffer, concatSubTree, copyArray, emptyAffix, foldLeftCb, foldLeftNode, foldLeftPrefix, foldLeftSuffix, foldRightCb, foldRightNode, foldRightPrefix, foldRightSuffix, getDepth, getHeight, getPrefixSize, getSuffixSize, handleOffset, incrementPrefix, incrementSuffix, mapAffix, mapNode, mapPrefix, mask, newAffix, newOffset, nodeNth, nodeNthDense, prependNodeToTree, reverseArray, setDepth, setPrefix, setSizes, setSuffix, sliceLeft, sliceRight, sliceTreeVector, updateNode, zeroOffset } from "@fncts/base/collection/immutable/Vector/internal";
 /**
  * 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 = getSuffixSize(as);
+function append_1(a) {
+  return as => {
+    const suffixSize = getSuffixSize(as);
 
-  if (suffixSize < 32) {
-    return new tsplus_module_1.Vector(incrementSuffix(as.bits), as.offset, as.length + 1, as.prefix, as.root, affixPush(a, as.suffix, suffixSize));
-  }
+    if (suffixSize < 32) {
+      return new tsplus_module_1.Vector(incrementSuffix(as.bits), as.offset, as.length + 1, as.prefix, as.root, affixPush(a, as.suffix, suffixSize));
+    }
 
-  const newSuffix = [a];
-  const newVector = mutableClone_1(as);
-  appendNodeToTree(newVector, as.suffix);
-  newVector.suffix = newSuffix;
-  newVector.length++;
-  newVector.bits = setSuffix(1, newVector.bits);
-  return newVector;
+    const newSuffix = [a];
+    const newVector = mutableClone_1(as);
+    appendNodeToTree(newVector, as.suffix);
+    newVector.suffix = newSuffix;
+    newVector.length++;
+    newVector.bits = 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
  */
 
 
-export function flatMap_(ma, f) {
-  return flatten_1(map_1(ma, f));
+export 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
- */
-
-export 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
+ */
+
+export 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);
+  };
 }
 
-function concat_1(self, that) {
-  if (self.length === 0) {
-    return that;
-  } else if (that.length === 0) {
-    return self;
-  }
+function concat_1(that) {
+  return self => {
+    if (self.length === 0) {
+      return that;
+    } else if (that.length === 0) {
+      return self;
+    }
 
-  const newSize = self.length + that.length;
-  const rightSuffixSize = getSuffixSize(that);
-  let newVector = mutableClone_1(self);
+    const newSize = self.length + that.length;
+    const rightSuffixSize = getSuffixSize(that);
+    let newVector = mutableClone_1(self);
 
-  if (that.root === undefined) {
-    // right is nothing but a prefix and a suffix
-    const nrOfAffixes = concatAffixes(self, that);
+    if (that.root === undefined) {
+      // right is nothing but a prefix and a suffix
+      const nrOfAffixes = concatAffixes(self, that);
 
-    for (let i = 0; i < nrOfAffixes; ++i) {
-      newVector = appendNodeToTree(newVector, concatBuffer[i]);
-      newVector.length += concatBuffer[i].length; // wipe pointer, otherwise it might end up keeping the array alive
+      for (let i = 0; i < nrOfAffixes; ++i) {
+        newVector = appendNodeToTree(newVector, concatBuffer[i]);
+        newVector.length += concatBuffer[i].length; // wipe pointer, otherwise it might end up keeping the array alive
 
-      concatBuffer[i] = undefined;
-    }
+        concatBuffer[i] = undefined;
+      }
 
-    newVector.length = newSize;
-    newVector.suffix = concatBuffer[nrOfAffixes];
-    newVector.bits = setSuffix(concatBuffer[nrOfAffixes].length, newVector.bits);
-    concatBuffer[nrOfAffixes] = undefined;
-    return newVector;
-  } else {
-    const leftSuffixSize = getSuffixSize(self);
+      newVector.length = newSize;
+      newVector.suffix = concatBuffer[nrOfAffixes];
+      newVector.bits = setSuffix(concatBuffer[nrOfAffixes].length, newVector.bits);
+      concatBuffer[nrOfAffixes] = undefined;
+      return newVector;
+    } else {
+      const leftSuffixSize = getSuffixSize(self);
 
-    if (leftSuffixSize > 0) {
-      newVector = appendNodeToTree(newVector, self.suffix.slice(0, leftSuffixSize));
-      newVector.length += leftSuffixSize;
-    }
+      if (leftSuffixSize > 0) {
+        newVector = appendNodeToTree(newVector, self.suffix.slice(0, leftSuffixSize));
+        newVector.length += leftSuffixSize;
+      }
 
-    newVector = appendNodeToTree(newVector, that.prefix.slice(0, getPrefixSize(that)).reverse());
-    const newNode = concatSubTree(newVector.root, getDepth(newVector), that.root, getDepth(that), true);
-    const newDepth = getHeight(newNode);
-    setSizes(newNode, newDepth);
-    newVector.root = newNode;
-    newVector.offset &= ~(mask << getDepth(self) * branchBits);
-    newVector.length = newSize;
-    newVector.bits = setSuffix(rightSuffixSize, setDepth(newDepth, newVector.bits));
-    newVector.suffix = that.suffix;
-    return newVector;
-  }
+      newVector = appendNodeToTree(newVector, that.prefix.slice(0, getPrefixSize(that)).reverse());
+      const newNode = concatSubTree(newVector.root, getDepth(newVector), that.root, getDepth(that), true);
+      const newDepth = getHeight(newNode);
+      setSizes(newNode, newDepth);
+      newVector.root = newNode;
+      newVector.offset &= ~(mask << getDepth(self) * branchBits);
+      newVector.length = newSize;
+      newVector.bits = setSuffix(rightSuffixSize, setDepth(newDepth, newVector.bits));
+      newVector.suffix = that.suffix;
+      return newVector;
+    }
+  };
 }
 
 const containsState = {
@@ -165,34 +173,40 @@ function containsCb(value, state) {
  * Otherwise it returns `false`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector contains
+ * @tsplus pipeable fncts.Vector contains
  */
 
 
-export function contains_(as, element) {
-  containsState.element = element;
-  containsState.result = false;
-  return foldLeftCb(containsCb, containsState, as).result;
+export function contains(element) {
+  return as => {
+    containsState.element = element;
+    containsState.result = false;
+    return 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
  */
 
-export function drop_(as, n) {
-  return slice_1(as, n, as.length);
+export 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
  */
 
-export function dropLast_(as, n) {
-  return slice_1(as, 0, as.length - n);
+export function dropLast(n) {
+  return as => {
+    return slice_1(0, as.length - n)(as);
+  };
 }
 /**
  * Returns a new Vector without repeated elements.
@@ -202,18 +216,20 @@ export function dropLast_(as, n) {
  */
 
 export 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) {
@@ -230,61 +246,67 @@ 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
  */
 
 
-export function dropWhile_(as, predicate) {
-  const {
-    index
-  } = foldLeftCb(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, index, as.length);
+export function dropWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = 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
  */
 
 
-export function elem_(self) {
-  return E => {
-    const elemState = {
-      equals: E.equals,
-      element: undefined,
-      result: false
-    };
-    return a => {
-      elemState.element = a;
-      return foldLeftCb(elemCb, elemState, self).result;
-    };
+export function elem(a,
+/** @tsplus auto */
+E) {
+  const elemState = {
+    equals: E.equals,
+    element: undefined,
+    result: false
+  };
+  return self => {
+    elemState.element = a;
+    return 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
  */
 
-export function equals_(self, that) {
-  return tsplus_module_4.corresponds_(self, that, tsplus_module_3.strictEquals);
+export 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);
 }
 
-export function every_(as, predicate) {
-  return foldLeftCb(everyCb, {
-    predicate,
-    result: true
-  }, as).result;
+export function every(predicate) {
+  return as => {
+    return foldLeftCb(everyCb, {
+      predicate,
+      result: true
+    }, as).result;
+  };
 }
 /**
  * Creates an empty Vector.
@@ -314,27 +336,31 @@ function existsCb(value, state) {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector exists
+ * @tsplus pipeable fncts.Vector exists
  */
 
 
-function exists_1(as, predicate) {
-  return foldLeftCb(existsCb, {
-    predicate,
-    result: false
-  }, as).result;
+function exists_1(predicate) {
+  return as => {
+    return 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
  */
 
 
-export function find_(as, predicate) {
-  return tsplus_module_5.fromNullable(unsafeFind_1(as, predicate));
+export function find(predicate) {
+  return as => {
+    return tsplus_module_5.fromNullable(unsafeFind_1(predicate)(as));
+  };
 }
 
 function findIndexCb(value, state) {
@@ -347,32 +373,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
-  } = foldLeftCb(findIndexCb, {
-    predicate,
-    found: false,
-    index: -1
-  }, as);
-  return found ? index : -1;
+function findIndex_1(predicate) {
+  return as => {
+    const {
+      found,
+      index
+    } = 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
  */
 
 
-export function findLast_(as, predicate) {
-  return tsplus_module_5.fromNullable(unsafeFindLast_1(as, predicate));
+export 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
@@ -380,19 +410,21 @@ export function findLast_(as, predicate) {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLastIndex
- */
-
-export function findLastIndex_(as, predicate) {
-  const {
-    found,
-    index
-  } = foldRightCb(findIndexCb, {
-    predicate,
-    found: false,
-    index: -0
-  }, as);
-  return found ? index : -1;
+ * @tsplus pipeable fncts.Vector findLastIndex
+ */
+
+export function findLastIndex(predicate) {
+  return as => {
+    const {
+      found,
+      index
+    } = 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
@@ -404,7 +436,7 @@ export 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);
 }
 
 export function from(sequence) {
@@ -412,14 +444,14 @@ export 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);
     }
   }
 
@@ -428,27 +460,31 @@ export 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 = getSuffixSize(fa);
-  const prefixSize = getPrefixSize(fa);
-  let [acc, index] = foldLeftPrefix(f, b, fa.prefix, prefixSize);
+function foldLeftWithIndex_1(b, f) {
+  return fa => {
+    const suffixSize = getSuffixSize(fa);
+    const prefixSize = getPrefixSize(fa);
+    let [acc, index] = foldLeftPrefix(f, b, fa.prefix, prefixSize);
 
-  if (fa.root !== undefined) {
-    [acc, index] = foldLeftNode(f, acc, fa.root, getDepth(fa), index);
-  }
+    if (fa.root !== undefined) {
+      [acc, index] = foldLeftNode(f, acc, fa.root, getDepth(fa), index);
+    }
 
-  return foldLeftSuffix(f, acc, fa.suffix, suffixSize, index)[0];
+    return foldLeftSuffix(f, acc, fa.suffix, suffixSize, index)[0];
+  };
 }
 /**
  * Similar to `foldl`. But, for each element it calls the predicate function
@@ -475,78 +511,90 @@ function foldWhileCb(a, state, i) {
   return true;
 }
 /**
- * @tsplus fluent fncts.Vector foldLeftWhile
+ * @tsplus pipeable fncts.Vector foldLeftWhile
  */
 
 
-export function foldLeftWhile_(fa, b, cont, f) {
-  if (!cont(b)) {
-    return b;
-  }
+export function foldLeftWhile(b, cont, f) {
+  return fa => {
+    if (!cont(b)) {
+      return b;
+    }
 
-  return foldLeftCb(foldWhileCb, {
-    predicate: cont,
-    f,
-    result: b
-  }, fa).result;
+    return foldLeftCb(foldWhileCb, {
+      predicate: cont,
+      f,
+      result: b
+    }, fa).result;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector foldRightWhile
+ * @tsplus pipeable fncts.Vector foldRightWhile
  */
 
-export function foldRightWhile_(fa, b, cont, f) {
-  return foldRightCb(foldWhileCb, {
-    predicate: cont,
-    result: b,
-    f: (i, b, a) => f(i, a, b)
-  }, fa).result;
+export function foldRightWhile(b, cont, f) {
+  return fa => {
+    return 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
  */
 
-export function foldMap_(self, f,
+export function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.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
  */
 
 
-export function foldRight_(fa, initial, f) {
-  return foldRightWithIndex_1(fa, initial, (_, a, b) => f(a, b));
+export 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 = getSuffixSize(fa);
-  const prefixSize = getPrefixSize(fa);
-  let [acc, j] = foldRightSuffix(f, b, fa.suffix, suffixSize, fa.length - 1);
+function foldRightWithIndex_1(b, f) {
+  return fa => {
+    const suffixSize = getSuffixSize(fa);
+    const prefixSize = getPrefixSize(fa);
+    let [acc, j] = foldRightSuffix(f, b, fa.suffix, suffixSize, fa.length - 1);
 
-  if (fa.root !== undefined) {
-    [acc, j] = foldRightNode(f, acc, fa.root, getDepth(fa), j);
-  }
+    if (fa.root !== undefined) {
+      [acc, j] = foldRightNode(f, acc, fa.root, getDepth(fa), j);
+    }
 
-  return foldRightPrefix(f, acc, fa.prefix, prefixSize, j)[0];
+    return foldRightPrefix(f, acc, fa.prefix, prefixSize, j)[0];
+  };
 }
 /**
  * Invokes a given callback for each element in the Vector from left to
@@ -558,31 +606,37 @@ 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
  */
 
 
-export function forEachWithIndex_(as, f) {
-  foldLeftWithIndex_1(as, undefined, (index, _, element) => f(index, element));
+export 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
  */
 
-export function get_(self, index) {
-  return tsplus_module_5.fromNullable(unsafeGet_1(self, index));
+export 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
@@ -592,21 +646,23 @@ export 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
  */
 
-export 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();
-    }
+export 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.
@@ -628,47 +684,55 @@ 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
  */
 
 
-export function indexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: -1
+export function indexOf(element) {
+  return as => {
+    const state = {
+      element,
+      found: false,
+      index: -1
+    };
+    foldLeftCb(indexOfCb, state, as);
+    return state.found ? state.index : -1;
   };
-  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
  */
 
-export function insertAt_(as, index, element) {
-  return concat_1(append_1(slice_1(as, 0, index), element), slice_1(as, index, as.length));
+export 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
  */
 
-export function insertAllAt_(as, index, elements) {
-  return concat_1(concat_1(slice_1(as, 0, index), elements), slice_1(as, index, as.length));
+export 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
  */
 
-export 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)));
+export 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
@@ -687,11 +751,13 @@ export function isNonEmpty(l) {
 /**
  * Concatenates the strings in the Vector separated by a specified separator.
  *
- * @tsplus fluent fncts.Vector join
+ * @tsplus pipeable fncts.Vector join
  */
 
-export function join_(as, separator) {
-  return foldLeft_1(as, "", (a, b) => a.length === 0 ? b : a + separator + b);
+export 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.
@@ -708,17 +774,19 @@ export 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
  */
 
-export function lastIndexOf_(as, element) {
-  const state = {
-    element,
-    found: false,
-    index: 0
+export function lastIndexOf(element) {
+  return as => {
+    const state = {
+      element,
+      found: false,
+      index: 0
+    };
+    foldRightCb(indexOfCb, state, as);
+    return state.found ? as.length - state.index : -1;
   };
-  foldRightCb(indexOfCb, state, as);
-  return state.found ? as.length - state.index : -1;
 }
 /**
  * Generates a new Vector by calling a function with the current index
@@ -732,44 +800,50 @@ export 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
  */
 
-export 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]];
-  });
+export 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, mapPrefix(f, fa.prefix, getPrefixSize(fa)), fa.root === undefined ? undefined : mapNode(f, fa.root, getDepth(fa), getPrefixSize(fa), 1)[0], mapAffix(f, fa.suffix, getSuffixSize(fa), fa.length));
+function mapWithIndex_1(f) {
+  return fa => {
+    return new tsplus_module_1.Vector(fa.bits, fa.offset, fa.length, mapPrefix(f, fa.prefix, getPrefixSize(fa)), fa.root === undefined ? undefined : mapNode(f, fa.root, getDepth(fa), getPrefixSize(fa), 1)[0], mapAffix(f, fa.suffix, getSuffixSize(fa), fa.length));
+  };
 }
 /**
  * @tsplus getter fncts.Vector mutableClone
@@ -788,16 +862,18 @@ function mutableClone_1(as) {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector modifyAt
+ * @tsplus pipeable fncts.Vector modifyAt
  */
 
 
-export function modifyAt_(as, i, f) {
-  if (i < 0 || as.length <= i) {
-    return as;
-  }
+export 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
@@ -805,11 +881,13 @@ export function modifyAt_(as, i, f) {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector none
+ * @tsplus pipeable fncts.Vector none
  */
 
-export function none_(as, predicate) {
-  return !exists_1(as, predicate);
+export function none(predicate) {
+  return as => {
+    return !exists_1(predicate)(as);
+  };
 }
 /**
  * Takes two arguments and returns a Vector that contains them.
@@ -830,31 +908,33 @@ export 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 = getPrefixSize(as);
+function prepend_1(a) {
+  return as => {
+    const prefixSize = getPrefixSize(as);
 
-  if (prefixSize < 32) {
-    return new tsplus_module_1.Vector(incrementPrefix(as.bits), as.offset, as.length + 1, affixPush(a, as.prefix, prefixSize), as.root, as.suffix);
-  } else {
-    const newVector = mutableClone_1(as);
-    prependNodeToTree(newVector, reverseArray(as.prefix));
-    const newPrefix = [a];
-    newVector.prefix = newPrefix;
-    newVector.length++;
-    newVector.bits = setPrefix(1, newVector.bits);
-    return newVector;
-  }
+    if (prefixSize < 32) {
+      return new tsplus_module_1.Vector(incrementPrefix(as.bits), as.offset, as.length + 1, affixPush(a, as.prefix, prefixSize), as.root, as.suffix);
+    } else {
+      const newVector = mutableClone_1(as);
+      prependNodeToTree(newVector, reverseArray(as.prefix));
+      const newPrefix = [a];
+      newVector.prefix = newPrefix;
+      newVector.length++;
+      newVector.bits = setPrefix(1, newVector.bits);
+      return newVector;
+    }
+  };
 }
 /**
  * @tsplus operator fncts.Vector +
@@ -862,7 +942,7 @@ function prepend_1(as, a) {
 
 
 export 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.
@@ -875,7 +955,7 @@ export 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;
@@ -887,11 +967,13 @@ export function range(start, end) {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector remove
+ * @tsplus pipeable fncts.Vector remove
  */
 
-export function remove_(as, from, amount) {
-  return concat_1(slice_1(as, 0, from), slice_1(as, from + amount, as.length));
+export 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
@@ -906,7 +988,7 @@ export 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;
@@ -916,17 +998,19 @@ export function replicate(n, a) {
  */
 
 export 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
  */
 
-export 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)));
+export 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.
@@ -944,114 +1028,118 @@ export 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 = getPrefixSize(as);
-  const suffixSize = getSuffixSize(as); // Both indices lie in the prefix
+    const newLength = _to - _from;
+    let prefixSize = getPrefixSize(as);
+    const suffixSize = getSuffixSize(as); // Both indices lie in the prefix
 
-  if (_to <= prefixSize) {
-    return new tsplus_module_1.Vector(setPrefix(newLength, 0), 0, newLength, as.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, emptyAffix);
-  }
+    if (_to <= prefixSize) {
+      return new tsplus_module_1.Vector(setPrefix(newLength, 0), 0, newLength, as.prefix.slice(prefixSize - _to, prefixSize - _from), undefined, 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(setSuffix(newLength, 0), 0, newLength, emptyAffix, undefined, as.suffix.slice(_from - suffixStart, _to - suffixStart));
-  }
+    if (suffixStart <= _from) {
+      return new tsplus_module_1.Vector(setSuffix(newLength, 0), 0, newLength, 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) {
-    sliceTreeVector(_from - prefixSize + as.offset, _to - prefixSize + as.offset - 1, as.root, getDepth(as), as.offset, newVector);
-    return newVector;
-  }
+    if (prefixSize <= _from && _to <= suffixStart) {
+      sliceTreeVector(_from - prefixSize + as.offset, _to - prefixSize + as.offset - 1, as.root, 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 = setPrefix(prefixSize - _from, bits);
-    } else {
-      // if we're here `_to` can't lie in the tree, so we can set the
-      // root
-      zeroOffset();
-      newVector.root = sliceLeft(newVector.root, getDepth(as), _from - prefixSize, as.offset, true);
-      newVector.offset = newOffset;
-
-      if (newVector.root === undefined) {
-        bits = 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 = setPrefix(prefixSize - _from, bits);
+      } else {
+        // if we're here `_to` can't lie in the tree, so we can set the
+        // root
+        zeroOffset();
+        newVector.root = sliceLeft(newVector.root, getDepth(as), _from - prefixSize, as.offset, true);
+        newVector.offset = newOffset;
+
+        if (newVector.root === undefined) {
+          bits = setDepth(0, bits);
+        }
+
+        bits = setPrefix(newAffix.length, bits);
+        prefixSize = newAffix.length;
+        newVector.prefix = newAffix;
       }
-
-      bits = setPrefix(newAffix.length, bits);
-      prefixSize = newAffix.length;
-      newVector.prefix = newAffix;
     }
-  }
 
-  if (_to < length) {
-    // we need _to slice something off of the right
-    if (length - _to < suffixSize) {
-      bits = 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 = 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 = sliceRight(newVector.root, getDepth(as), _to - prefixSize - 1, newVector.offset);
+        newVector.suffix = as.suffix.slice(0, suffixSize - (length - _to));
+      } else {
+        newVector.root = sliceRight(newVector.root, getDepth(as), _to - prefixSize - 1, newVector.offset);
 
-      if (newVector.root === undefined) {
-        bits = setDepth(0, bits);
-        newVector.offset = 0;
-      }
+        if (newVector.root === undefined) {
+          bits = setDepth(0, bits);
+          newVector.offset = 0;
+        }
 
-      bits = setSuffix(newAffix.length, bits);
-      newVector.suffix = newAffix;
+        bits = setSuffix(newAffix.length, bits);
+        newVector.suffix = newAffix;
+      }
     }
-  }
 
-  newVector.bits = bits;
-  return newVector;
+    newVector.bits = bits;
+    return newVector;
+  };
 }
 /**
- * @tsplus fluent fncts.Vector sort
+ * @tsplus pipeable fncts.Vector sort
  */
 
 
-export function sort_(self,
+export 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.
@@ -1062,33 +1150,35 @@ 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.
@@ -1098,12 +1188,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
@@ -1111,13 +1203,15 @@ function splitAt_1(as, index) {
  *
  * @complexity `O(n)`
  *
- * @tsplus fluent fncts.Vector splitWhen
+ * @tsplus pipeable fncts.Vector splitWhen
  */
 
 
-export function splitWhen_(as, predicate) {
-  const idx = findIndex_1(as, predicate);
-  return idx === -1 ? [as, empty_1()] : splitAt_1(as, idx);
+export 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
@@ -1129,17 +1223,19 @@ export function splitWhen_(as, predicate) {
  */
 
 export 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
  */
 
-export function take_(as, n) {
-  return slice_1(as, 0, n);
+export function take(n) {
+  return as => {
+    return slice_1(0, n)(as);
+  };
 }
 /**
  * Takes the first elements in the Vector for which the predicate returns
@@ -1148,28 +1244,32 @@ export 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
  */
 
-export function takeWhile_(as, predicate) {
-  const {
-    index
-  } = foldLeftCb(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, 0, index);
+export function takeWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = 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
  */
 
-export function takeLast_(as, n) {
-  return slice_1(as, as.length - n, as.length);
+export 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
@@ -1178,17 +1278,19 @@ export 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
  */
 
-export function takeLastWhile_(as, predicate) {
-  const {
-    index
-  } = foldRightCb(findNotIndexCb, {
-    predicate,
-    index: 0
-  }, as);
-  return slice_1(as, as.length - index, as.length);
+export function takeLastWhile(predicate) {
+  return as => {
+    const {
+      index
+    } = foldRightCb(findNotIndexCb, {
+      predicate,
+      index: 0
+    }, as);
+    return slice_1(as.length - index, as.length)(as);
+  };
 }
 /**
  * Converts a Vector into an array.
@@ -1198,7 +1300,7 @@ export function takeLastWhile_(as, predicate) {
  */
 
 export function toArray(self) {
-  return foldLeft_1(self, [], arrayPush);
+  return foldLeft_1([], arrayPush)(self);
 }
 /**
  * Converts a Vector into a List.
@@ -1209,27 +1311,28 @@ export function toArray(self) {
 
 export 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) => {
-    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;
-  }));
-});
-export const traverseWithIndex = traverseWithIndex_1;
+  })(b))(self);
+}
 /**
  * @tsplus getter fncts.Vector traverse
  */
 
-export const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+
+export function _traverse(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+export const traverseWithIndex = G => f => self => _traverseWithIndex_1(self)(G)(f);
+export const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
@@ -1239,7 +1342,7 @@ export const traverse = self => G => f => traverseWithIndex_1(self)(G)((_, a) =>
  */
 
 export function uniq(as) {
-  return E => dropRepeatsWith_1(as, E.equals);
+  return E => dropRepeatsWith_1(E.equals)(as);
 }
 /**
  * @tsplus static fncts.VectorOps unfold
@@ -1252,9 +1355,9 @@ export 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;
@@ -1277,59 +1380,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 foldLeftCb(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+function unsafeFind_1(predicate) {
+  return as => {
+    return 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 foldRightCb(findCb, {
-    predicate,
-    result: undefined
-  }, as).result;
+function unsafeFindLast_1(predicate) {
+  return as => {
+    return 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 = getPrefixSize(l);
-  const suffixSize = getSuffixSize(l);
+    const prefixSize = getPrefixSize(l);
+    const suffixSize = 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 = getDepth(l);
-  return l.root.sizes === undefined ? nodeNthDense(l.root, depth, offset === 0 ? index - prefixSize : handleOffset(depth, offset, index - prefixSize)) : nodeNth(l.root, depth, offset, index - prefixSize);
+    const {
+      offset
+    } = l;
+    const depth = getDepth(l);
+    return l.root.sizes === undefined ? nodeNthDense(l.root, depth, offset === 0 ? index - prefixSize : handleOffset(depth, offset, index - prefixSize)) : nodeNth(l.root, depth, offset, index - prefixSize);
+  };
 }
 /**
  * Returns the first element of the Vector. If the Vector is empty the
@@ -1363,32 +1473,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 = getPrefixSize(as);
-  const suffixSize = getSuffixSize(as);
-  const newVector = mutableClone_1(as);
-
-  if (i < prefixSize) {
-    const newPrefix = copyArray(newVector.prefix);
-    newPrefix[newPrefix.length - i - 1] = a;
-    newVector.prefix = newPrefix;
-  } else if (i >= as.length - suffixSize) {
-    const newSuffix = copyArray(newVector.suffix);
-    newSuffix[i - (as.length - suffixSize)] = a;
-    newVector.suffix = newSuffix;
-  } else {
-    newVector.root = updateNode(as.root, getDepth(as), i - prefixSize, as.offset, a);
-  }
+    const prefixSize = getPrefixSize(as);
+    const suffixSize = getSuffixSize(as);
+    const newVector = mutableClone_1(as);
 
-  return newVector;
+    if (i < prefixSize) {
+      const newPrefix = copyArray(newVector.prefix);
+      newPrefix[newPrefix.length - i - 1] = a;
+      newVector.prefix = newPrefix;
+    } else if (i >= as.length - suffixSize) {
+      const newSuffix = copyArray(newVector.suffix);
+      newSuffix[i - (as.length - suffixSize)] = a;
+      newVector.suffix = newSuffix;
+    } else {
+      newVector.root = updateNode(as.root, getDepth(as), i - prefixSize, as.offset, a);
+    }
+
+    return newVector;
+  };
 }
 /**
  * @tsplus static fncts.VectorOps __call
@@ -1399,7 +1511,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;