@fncts/base 0.0.20 → 0.0.22

package/_src/collection/immutable/Vector/api.ts

@@ -1,6 +1,7 @@
 /* eslint-disable prefer-const */
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
 import type { Eq, Monoid, Ord, Ordering, Traversable } from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 
 import {
   affixPush,
@@ -48,115 +49,122 @@ import {
   updateNode,
   zeroOffset,
 } from "@fncts/base/collection/immutable/Vector/internal";
-import { TraversableWithIndex } from "@fncts/base/typeclass";
 
 /**
  * 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 +
- */
-export function append_<A>(as: Vector<A>, a: A): Vector<A> {
-  const suffixSize = getSuffixSize(as);
-  if (suffixSize < 32) {
-    return new Vector(
-      incrementSuffix(as.bits),
-      as.offset,
-      as.length + 1,
-      as.prefix,
-      as.root,
-      affixPush(a, as.suffix, suffixSize),
-    );
-  }
-  const newSuffix = [a];
-  const newVector = mutableClone(as);
-  appendNodeToTree(newVector, as.suffix);
-  newVector.suffix = newSuffix;
-  newVector.length++;
-  newVector.bits = setSuffix(1, newVector.bits);
-  return newVector;
+ * @tsplus pipeable fncts.Vector append
+ * @tsplus pipeable-operator fncts.Vector +
+ */
+export function append<A>(a: A) {
+  return (self: Vector<A>): Vector<A> => {
+    const suffixSize = getSuffixSize(self);
+    if (suffixSize < 32) {
+      return new Vector(
+        incrementSuffix(self.bits),
+        self.offset,
+        self.length + 1,
+        self.prefix,
+        self.root,
+        affixPush(a, self.suffix, suffixSize),
+      );
+    }
+    const newSuffix = [a];
+    const newVector = mutableClone(self);
+    appendNodeToTree(newVector, self.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_<A, B>(ma: Vector<A>, f: (a: A) => Vector<B>): Vector<B> {
-  return ma.map(f).flatten;
+export function flatMap<A, B>(f: (a: A) => Vector<B>) {
+  return (self: Vector<A>): Vector<B> => {
+    return self.map(f).flatten;
+  };
 }
 
 /**
  * Splits the Vector into chunks of the given size.
  *
- * @tsplus fluent fncts.Vector chunksOf
- */
-export function chunksOf_<A>(as: Vector<A>, size: number): Vector<Vector<A>> {
-  const { buffer, l2 } = as.foldLeft(
-    { l2: Vector.emptyPushable<Vector<A>>(), buffer: Vector.emptyPushable<A>() },
-    ({ buffer, l2 }, elem) => {
-      buffer.push(elem);
-      if (buffer.length === size) {
-        return { l2: l2.push(buffer), buffer: Vector.emptyPushable<A>() };
-      } else {
-        return { l2, buffer };
-      }
-    },
-  );
-  return buffer.length === 0 ? l2 : l2.push(buffer);
+ * @tsplus pipeable fncts.Vector chunksOf
+ */
+export function chunksOf(size: number) {
+  return <A>(self: Vector<A>): Vector<Vector<A>> => {
+    const { buffer, l2 } = self.foldLeft(
+      { l2: Vector.emptyPushable<Vector<A>>(), buffer: Vector.emptyPushable<A>() },
+      ({ buffer, l2 }, elem) => {
+        buffer.push(elem);
+        if (buffer.length === size) {
+          return { l2: l2.push(buffer), buffer: Vector.emptyPushable<A>() };
+        } else {
+          return { l2, buffer };
+        }
+      },
+    );
+    return buffer.length === 0 ? l2 : l2.push(buffer);
+  };
 }
 
 /**
  * Concatenates two Vectors.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector concat
- * @tsplus operator fncts.Vector + 1
- */
-export function concat_<A, B>(self: Vector<A>, that: Vector<B>): Vector<A | B>;
-export function concat_<A>(self: Vector<A>, that: Vector<A>): Vector<A> {
-  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         = self.mutableClone;
-  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
-      concatBuffer[i] = undefined;
+ * @tsplus pipeable fncts.Vector concat
+ * @tsplus pipeable-operator fncts.Vector + 1
+ */
+export function concat<B>(that: Vector<B>): <A>(self: Vector<A>) => Vector<A | B>;
+export function concat<A>(that: Vector<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    if (self.length === 0) {
+      return that;
+    } else if (that.length === 0) {
+      return 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;
+    const newSize         = self.length + that.length;
+    const rightSuffixSize = getSuffixSize(that);
+    let newVector         = self.mutableClone;
+    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
+        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);
+      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;
-  }
+  };
 }
 
 type ContainsState = {
@@ -178,32 +186,38 @@ function containsCb(value: any, state: ContainsState): boolean {
  * Otherwise it returns `false`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector contains
+ * @tsplus pipeable fncts.Vector contains
  */
-export function contains_<A>(as: Vector<A>, element: A): boolean {
-  containsState.element = element;
-  containsState.result  = false;
-  return foldLeftCb(containsCb, containsState, as).result;
+export function contains<A>(element: A) {
+  return (self: Vector<A>): boolean => {
+    containsState.element = element;
+    containsState.result  = false;
+    return foldLeftCb(containsCb, containsState, self).result;
+  };
 }
 
 /**
  * Returns a new Vector without the first `n` elements.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector drop
+ * @tsplus pipeable fncts.Vector drop
  */
-export function drop_<A>(as: Vector<A>, n: number): Vector<A> {
-  return as.slice(n, as.length);
+export function drop(n: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    return self.slice(n, self.length);
+  };
 }
 
 /**
  * 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_<A>(as: Vector<A>, n: number): Vector<A> {
-  return as.slice(0, as.length - n);
+export function dropLast(n: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    return self.slice(0, self.length - n);
+  };
 }
 
 /**
@@ -212,8 +226,8 @@ export function dropLast_<A>(as: Vector<A>, n: number): Vector<A> {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector dropRepeats
  */
-export function dropRepeats<A>(as: Vector<A>): Vector<A> {
-  return as.dropRepeatsWith(Equatable.strictEquals);
+export function dropRepeats<A>(self: Vector<A>): Vector<A> {
+  return self.dropRepeatsWith(Equatable.strictEquals);
 }
 
 /**
@@ -221,12 +235,14 @@ export function dropRepeats<A>(as: Vector<A>): Vector<A> {
  * function to determine when elements are equal.
  *
  * @complexity `O(n)`
- * @tsplus fluent fncts.Vector dropRepeatsWith
+ * @tsplus pipeable fncts.Vector dropRepeatsWith
  */
-export function dropRepeatsWith_<A>(as: Vector<A>, predicate: (a: A, b: A) => boolean): Vector<A> {
-  return as.foldLeft(Vector.emptyPushable(), (acc, a) =>
-    acc.length !== 0 && predicate((acc as Vector<A>).unsafeLast!, a) ? acc : acc.push(a),
-  );
+export function dropRepeatsWith<A>(predicate: (a: A, b: A) => boolean) {
+  return (self: Vector<A>): Vector<A> => {
+    return self.foldLeft(Vector.emptyPushable(), (acc, a) =>
+      acc.length !== 0 && predicate((acc as Vector<A>).unsafeLast!, a) ? acc : acc.push(a),
+    );
+  };
 }
 
 type FindNotIndexState = {
@@ -249,44 +265,45 @@ function findNotIndexCb(value: any, state: FindNotIndexState): boolean {
  *
  * @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_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A> {
-  const { index } = foldLeftCb(findNotIndexCb, { predicate, index: 0 }, as);
-  return as.slice(index, as.length);
+export function dropWhile<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    const { index } = foldLeftCb(findNotIndexCb, { predicate, index: 0 }, self);
+    return self.slice(index, self.length);
+  };
 }
 
 type ElemState = {
   element: any;
-  equals: (x: any, y: any) => boolean;
+  equals: (y: any) => (x: any) => boolean;
   result: boolean;
 };
 
 function elemCb(value: any, state: ElemState): boolean {
-  return !(state.result = state.equals(value, state.element));
+  return !(state.result = state.equals(state.element)(value));
 }
 
 /**
- * @tsplus getter fncts.Vector elem
+ * @tsplus pipeable fncts.Vector elem
  */
-export function elem_<A>(self: Vector<A>) {
-  return (E: Eq<A>) => {
-    const elemState: ElemState = { equals: E.equals, element: undefined, result: false };
-    return (a: A): boolean => {
-      elemState.element = a;
-      return foldLeftCb(elemCb, elemState, self).result;
-    };
+export function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>) {
+  const elemState: ElemState = { equals: E.equals, element: undefined, result: false };
+  return (self: Vector<A>): boolean => {
+    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_<A>(self: Vector<A>, that: Vector<A>): boolean {
-  return self.corresponds(that, Equatable.strictEquals);
+export function equals<A>(that: Vector<A>) {
+  return (self: Vector<A>): boolean => {
+    return self.corresponds(that, Equatable.strictEquals);
+  };
 }
 
 type PredState = {
@@ -303,12 +320,14 @@ function everyCb<A>(value: A, state: any): boolean {
  * for all elements in the given Vector.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector every
+ * @tsplus pipeable fncts.Vector every
  */
-export function every_<A, B extends A>(as: Vector<A>, refinement: Refinement<A, B>): as is Vector<B>;
-export function every_<A>(as: Vector<A>, predicate: Predicate<A>): boolean;
-export function every_<A>(as: Vector<A>, predicate: Predicate<A>): boolean {
-  return foldLeftCb<A, PredState>(everyCb, { predicate, result: true }, as).result;
+export function every<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => self is Vector<B>;
+export function every<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
+export function every<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): boolean => {
+    return foldLeftCb<A, PredState>(everyCb, { predicate, result: true }, self).result;
+  };
 }
 
 /**
@@ -317,18 +336,18 @@ export function every_<A>(as: Vector<A>, predicate: Predicate<A>): boolean {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps empty
  */
-export function empty<A = any>(): Vector<A> {
+export function empty<A = never>(): Vector<A> {
   return new Vector(0, 0, 0, emptyAffix, undefined, emptyAffix);
 }
 
 /**
  * @tsplus static fncts.VectorOps emptyPushable
  */
-export function emptyPushable<A>(): MutableVector<A> {
+export function emptyPushable<A = never>(): MutableVector<A> {
   return new Vector(0, 0, 0, [], undefined, []) as any;
 }
 
-function existsCb<A>(value: A, state: PredState): boolean {
+function someCb<A>(value: A, state: PredState): boolean {
   return !(state.result = state.predicate(value));
 }
 
@@ -338,10 +357,12 @@ function existsCb<A>(value: A, state: PredState): boolean {
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector exists
+ * @tsplus pipeable fncts.Vector some
  */
-export function exists_<A>(as: Vector<A>, predicate: Predicate<A>): boolean {
-  return foldLeftCb<A, PredState>(existsCb, { predicate, result: false }, as).result;
+export function some<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): boolean => {
+    return foldLeftCb<A, PredState>(someCb, { predicate, result: false }, self).result;
+  };
 }
 
 /**
@@ -349,10 +370,12 @@ export function exists_<A>(as: Vector<A>, predicate: Predicate<A>): boolean {
  * 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_<A>(as: Vector<A>, predicate: Predicate<A>): Maybe<A> {
-  return Maybe.fromNullable(as.unsafeFind(predicate));
+export function find<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): Maybe<A> => {
+    return Maybe.fromNullable(self.unsafeFind(predicate));
+  };
 }
 
 type FindIndexState = {
@@ -372,11 +395,13 @@ function findIndexCb<A>(value: A, state: FindIndexState): boolean {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findIndex
+ * @tsplus pipeable fncts.Vector findIndex
  */
-export function findIndex_<A>(as: Vector<A>, predicate: Predicate<A>): number {
-  const { found, index } = foldLeftCb<A, FindIndexState>(findIndexCb, { predicate, found: false, index: -1 }, as);
-  return found ? index : -1;
+export function findIndex<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): number => {
+    const { found, index } = foldLeftCb<A, FindIndexState>(findIndexCb, { predicate, found: false, index: -1 }, self);
+    return found ? index : -1;
+  };
 }
 
 /**
@@ -384,10 +409,12 @@ export function findIndex_<A>(as: Vector<A>, predicate: Predicate<A>): number {
  * 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_<A>(as: Vector<A>, predicate: Predicate<A>): Maybe<A> {
-  return Maybe.fromNullable(as.unsafeFindLast(predicate));
+export function findLast<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): Maybe<A> => {
+    return Maybe.fromNullable(self.unsafeFindLast(predicate));
+  };
 }
 
 /**
@@ -396,11 +423,13 @@ export function findLast_<A>(as: Vector<A>, predicate: Predicate<A>): Maybe<A> {
  * `-1`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLastIndex
+ * @tsplus pipeable fncts.Vector findLastIndex
  */
-export function findLastIndex_<A>(as: Vector<A>, predicate: Predicate<A>): number {
-  const { found, index } = foldRightCb<A, FindIndexState>(findIndexCb, { predicate, found: false, index: -0 }, as);
-  return found ? index : -1;
+export function findLastIndex<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): number => {
+    const { found, index } = foldRightCb<A, FindIndexState>(findIndexCb, { predicate, found: false, index: -0 }, self);
+    return found ? index : -1;
+  };
 }
 
 /**
@@ -411,8 +440,8 @@ export function findLastIndex_<A>(as: Vector<A>, predicate: Predicate<A>): numbe
  *
  * @tsplus getter fncts.Vector flatten
  */
-export function flatten<A>(mma: Vector<Vector<A>>): Vector<A> {
-  return mma.foldLeft<Vector<A>, Vector<A>>(Vector.empty(), (acc, a) => acc.concat(a));
+export function flatten<A>(self: Vector<Vector<A>>): Vector<A> {
+  return self.foldLeft<Vector<A>, Vector<A>>(Vector.empty(), (acc, a) => acc.concat(a));
 }
 
 /**
@@ -441,23 +470,27 @@ export function from<A>(sequence: any): Vector<A> {
 /**
  * Folds a function over a Vector. Left-associative.
  *
- * @tsplus fluent fncts.Vector foldLeft
+ * @tsplus pipeable fncts.Vector foldLeft
  */
-export function foldLeft_<A, B>(fa: Vector<A>, initial: B, f: (acc: B, a: A) => B): B {
-  return fa.foldLeftWithIndex(initial, (_, b, a) => f(b, a));
+export function foldLeft<A, B>(initial: B, f: (acc: B, a: A) => B) {
+  return (self: Vector<A>): B => {
+    return self.foldLeftWithIndex(initial, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Vector foldLeftWithIndex
+ * @tsplus pipeable fncts.Vector foldLeftWithIndex
  */
-export function foldLeftWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: number, b: B, a: A) => B): B {
-  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);
-  }
-  return foldLeftSuffix(f, acc, fa.suffix, suffixSize, index)[0];
+export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
+  return (self: Vector<A>): B => {
+    const suffixSize = getSuffixSize(self);
+    const prefixSize = getPrefixSize(self);
+    let [acc, index] = foldLeftPrefix(f, b, self.prefix, prefixSize);
+    if (self.root !== undefined) {
+      [acc, index] = foldLeftNode(f, acc, self.root, getDepth(self), index);
+    }
+    return foldLeftSuffix(f, acc, self.suffix, suffixSize, index)[0];
+  };
 }
 
 type FoldWhileState<A, B> = {
@@ -489,68 +522,76 @@ function foldWhileCb<A, B>(a: A, state: FoldWhileState<A, B>, i: number): boolea
 }
 
 /**
- * @tsplus fluent fncts.Vector foldLeftWhile
+ * @tsplus pipeable fncts.Vector foldLeftWhile
  */
-export function foldLeftWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B): B {
-  if (!cont(b)) {
-    return b;
-  }
-  return foldLeftCb<A, FoldWhileState<A, B>>(foldWhileCb, { predicate: cont, f, result: b }, fa).result;
+export function foldLeftWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B) {
+  return (self: Vector<A>): B => {
+    if (!cont(b)) {
+      return b;
+    }
+    return foldLeftCb<A, FoldWhileState<A, B>>(foldWhileCb, { predicate: cont, f, result: b }, self).result;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Vector foldRightWhile
+ * @tsplus pipeable fncts.Vector foldRightWhile
  */
-export function foldRightWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): B {
-  return foldRightCb<A, FoldWhileState<A, B>>(
-    foldWhileCb,
-    { predicate: cont, result: b, f: (i, b, a) => f(i, a, b) },
-    fa,
-  ).result;
+export function foldRightWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B) {
+  return (self: Vector<A>): B => {
+    return foldRightCb<A, FoldWhileState<A, B>>(
+      foldWhileCb,
+      { predicate: cont, result: b, f: (i, b, a) => f(i, a, b) },
+      self,
+    ).result;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Vector foldMap
+ * @tsplus pipeable fncts.Vector foldMap
  */
-export function foldMap_<A, M>(self: Vector<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
-  return self.foldMapWithIndex((_, a) => f(a), M);
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: Vector<A>): M => {
+    return self.foldMapWithIndex((_, a) => f(a), M);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Vector foldMapWithIndex
+ * @tsplus pipeable fncts.Vector foldMapWithIndex
  */
-export function foldMapWithIndex_<A, M>(
-  self: Vector<A>,
-  f: (i: number, a: A) => M,
-  /** @tsplus auto */ M: Monoid<M>,
-): M {
-  return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
+  return (self: Vector<A>): M => {
+    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
+  };
 }
 
 /**
  * Folds a function over a Vector. Right-associative.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRight
+ * @tsplus pipeable fncts.Vector foldRight
  */
-export function foldRight_<A, B>(fa: Vector<A>, initial: B, f: (value: A, acc: B) => B): B {
-  return fa.foldRightWithIndex(initial, (_, a, b) => f(a, b));
+export function foldRight<A, B>(initial: B, f: (value: A, acc: B) => B) {
+  return (self: Vector<A>): B => {
+    return self.foldRightWithIndex(initial, (_, a, b) => f(a, b));
+  };
 }
 
 /**
  * Folds a function over a Vector. Right-associative.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRightWithIndex
- */
-export function foldRightWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: number, a: A, b: B) => B): B {
-  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);
-  }
-  return foldRightPrefix(f, acc, fa.prefix, prefixSize, j)[0];
+ * @tsplus pipeable fncts.Vector foldRightWithIndex
+ */
+export function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B) {
+  return (self: Vector<A>): B => {
+    const suffixSize = getSuffixSize(self);
+    const prefixSize = getPrefixSize(self);
+    let [acc, j]     = foldRightSuffix(f, b, self.suffix, suffixSize, self.length - 1);
+    if (self.root !== undefined) {
+      [acc, j] = foldRightNode(f, acc, self.root, getDepth(self), j);
+    }
+    return foldRightPrefix(f, acc, self.prefix, prefixSize, j)[0];
+  };
 }
 
 /**
@@ -563,17 +604,21 @@ export function foldRightWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: number, a:
  * makes `forEach` faster when the new Vector is unneeded.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector forEach
+ * @tsplus pipeable fncts.Vector forEach
  */
-export function forEach_<A>(as: Vector<A>, f: (a: A) => void): void {
-  as.foldLeft(undefined as void, (_, element) => f(element));
+export function forEach<A>(f: (a: A) => void) {
+  return (self: Vector<A>): void => {
+    self.foldLeft(undefined as void, (_, element) => f(element));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Vector forEachWithIndex
+ * @tsplus pipeable fncts.Vector forEachWithIndex
  */
-export function forEachWithIndex_<A>(as: Vector<A>, f: (i: number, a: A) => void): void {
-  as.foldLeftWithIndex(undefined as void, (index, _, element) => f(index, element));
+export function forEachWithIndex<A>(f: (i: number, a: A) => void) {
+  return (self: Vector<A>): void => {
+    self.foldLeftWithIndex(undefined as void, (index, _, element) => f(index, element));
+  };
 }
 
 /**
@@ -581,10 +626,12 @@ export function forEachWithIndex_<A>(as: Vector<A>, f: (i: number, a: A) => void
  * `undefined` is returned.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector get
+ * @tsplus pipeable fncts.Vector get
  */
-export function get_<A>(self: Vector<A>, index: number): Maybe<A> {
-  return Maybe.fromNullable(self.unsafeGet(index));
+export function get(index: number) {
+  return <A>(self: Vector<A>): Maybe<A> => {
+    return Maybe.fromNullable(self.unsafeGet(index));
+  };
 }
 
 /**
@@ -595,19 +642,21 @@ export function get_<A>(self: Vector<A>, index: number): Maybe<A> {
  * 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_<A>(as: Vector<A>, f: (a: A, b: A) => boolean): Vector<Vector<A>> {
-  const result = Vector.emptyPushable<MutableVector<A>>();
-  let buffer   = Vector.emptyPushable<A>();
-  forEach_(as, (a) => {
-    if (buffer.length !== 0 && !f(unsafeLast(buffer)!, a)) {
-      result.push(buffer);
-      buffer = emptyPushable();
-    }
-    buffer.push(a);
-  });
-  return buffer.length === 0 ? result : result.push(buffer);
+export function groupWith<A>(f: (a: A, b: A) => boolean) {
+  return (self: Vector<A>): Vector<Vector<A>> => {
+    const result = Vector.emptyPushable<MutableVector<A>>();
+    let buffer   = Vector.emptyPushable<A>();
+    self.forEach((a) => {
+      if (buffer.length !== 0 && !f(unsafeLast(buffer)!, a)) {
+        result.push(buffer);
+        buffer = emptyPushable();
+      }
+      buffer.push(a);
+    });
+    return buffer.length === 0 ? result : result.push(buffer);
+  };
 }
 
 /**
@@ -636,64 +685,74 @@ function indexOfCb(value: any, state: IndexOfState): boolean {
  * 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_<A>(as: Vector<A>, element: A): number {
-  const state = { element, found: false, index: -1 };
-  foldLeftCb(indexOfCb, state, as);
-  return state.found ? state.index : -1;
+export function indexOf<A>(element: A) {
+  return (self: Vector<A>): number => {
+    const state = { element, found: false, index: -1 };
+    foldLeftCb(indexOfCb, state, self);
+    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_<A>(as: Vector<A>, index: number, element: A): Vector<A> {
-  return as.slice(0, index).append(element).concat(as.slice(index, as.length));
+export function insertAt<A>(index: number, element: A) {
+  return (self: Vector<A>): Vector<A> => {
+    return self.slice(0, index).append(element).concat(self.slice(index, self.length));
+  };
 }
 
 /**
  * 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_<A>(as: Vector<A>, index: number, elements: Vector<A>): Vector<A> {
-  return as.slice(0, index).concat(elements).concat(as.slice(index, as.length));
+export function insertAllAt<A>(index: number, elements: Vector<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    return self.slice(0, index).concat(elements).concat(self.slice(index, self.length));
+  };
 }
 
 /**
  * Inserts a separator between each element in a Vector.
  *
- * @tsplus fluent fncts.Vector intersperse
+ * @tsplus pipeable fncts.Vector intersperse
  */
-export function intersperse_<A>(as: Vector<A>, separator: A): Vector<A> {
-  return (as.foldLeft(Vector.emptyPushable(), (l2, a) => l2.push(a).push(separator)) as Vector<A>).pop;
+export function intersperse<A>(separator: A) {
+  return (self: Vector<A>): Vector<A> => {
+    return (self.foldLeft(Vector.emptyPushable(), (l2, a) => l2.push(a).push(separator)) as Vector<A>).pop;
+  };
 }
 
 /**
  * @tsplus fluent fncts.Vector isEmpty
  */
-export function isEmpty<A>(l: Vector<A>): boolean {
-  return l.length === 0;
+export function isEmpty<A>(self: Vector<A>): boolean {
+  return self.length === 0;
 }
 
 /**
  * @tsplus fluent fncts.Vector isNonEmpty
  */
-export function isNonEmpty<A>(l: Vector<A>): boolean {
-  return l.length > 0;
+export function isNonEmpty<A>(self: Vector<A>): boolean {
+  return self.length > 0;
 }
 
 /**
  * Concatenates the strings in the Vector separated by a specified separator.
  *
- * @tsplus fluent fncts.Vector join
+ * @tsplus pipeable fncts.Vector join
  */
-export function join_(as: Vector<string>, separator: string): string {
-  return as.foldLeft("", (a, b) => (a.length === 0 ? b : a + separator + b));
+export function join(separator: string) {
+  return (self: Vector<string>): string => {
+    return self.foldLeft("", (a, b) => (a.length === 0 ? b : a + separator + b));
+  };
 }
 
 /**
@@ -702,8 +761,8 @@ export function join_(as: Vector<string>, separator: string): string {
  * @complexity O(1)
  * @tsplus getter fncts.Vector last
  */
-export function last<A>(l: Vector<A>): Maybe<NonNullable<A>> {
-  return Maybe.fromNullable(l.unsafeLast);
+export function last<A>(self: Vector<A>): Maybe<NonNullable<A>> {
+  return Maybe.fromNullable(self.unsafeLast);
 }
 
 /**
@@ -711,12 +770,14 @@ export function last<A>(l: Vector<A>): Maybe<NonNullable<A>> {
  * 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_<A>(as: Vector<A>, element: A): number {
-  const state = { element, found: false, index: 0 };
-  foldRightCb(indexOfCb, state, as);
-  return state.found ? as.length - state.index : -1;
+export function lastIndexOf<A>(element: A) {
+  return (self: Vector<A>): number => {
+    const state = { element, found: false, index: 0 };
+    foldRightCb(indexOfCb, state, self);
+    return state.found ? self.length - state.index : -1;
+  };
 }
 
 /**
@@ -735,14 +796,16 @@ export function makeBy<A>(n: number, f: (index: number) => A): Vector<A> {
 }
 
 /**
- * @tsplus fluent fncts.Vector mapAccum
+ * @tsplus pipeable fncts.Vector mapAccum
  */
-export function mapAccum_<A, S, B>(fa: Vector<A>, s: S, f: (s: S, a: A) => readonly [B, S]): readonly [Vector<B>, S] {
-  return fa.foldLeft([Vector.emptyPushable(), s], ([acc, s], a) => {
-    const r = f(s, a);
-    acc.push(r[0]);
-    return [acc, r[1]];
-  });
+export function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]) {
+  return (self: Vector<A>): readonly [Vector<B>, S] => {
+    return self.foldLeft([Vector.emptyPushable(), s], ([acc, s], a) => {
+      const r = f(s, a);
+      acc.push(r[0]);
+      return [acc, r[1]];
+    });
+  };
 }
 
 /**
@@ -750,10 +813,12 @@ export function mapAccum_<A, S, B>(fa: Vector<A>, s: S, f: (s: S, a: A) => reado
  * new Vector of the values that the function return.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector map
+ * @tsplus pipeable fncts.Vector map
  */
-export function map_<A, B>(fa: Vector<A>, f: (a: A) => B): Vector<B> {
-  return fa.mapWithIndex((_, a) => f(a));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Vector<A>): Vector<B> => {
+    return self.mapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
@@ -761,24 +826,26 @@ export function map_<A, B>(fa: Vector<A>, f: (a: A) => B): Vector<B> {
  * new Vector of the values that the function return.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector mapWithIndex
+ * @tsplus pipeable fncts.Vector mapWithIndex
  */
-export function mapWithIndex_<A, B>(fa: Vector<A>, f: (i: number, a: A) => B): Vector<B> {
-  return new 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),
-  );
+export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
+  return (self: Vector<A>): Vector<B> => {
+    return new Vector(
+      self.bits,
+      self.offset,
+      self.length,
+      mapPrefix(f, self.prefix, getPrefixSize(self)),
+      self.root === undefined ? undefined : mapNode(f, self.root, getDepth(self), getPrefixSize(self), 1)[0],
+      mapAffix(f, self.suffix, getSuffixSize(self), self.length),
+    );
+  };
 }
 
 /**
  * @tsplus getter fncts.Vector mutableClone
  */
-export function mutableClone<A>(as: Vector<A>): MutableVector<A> {
-  return new Vector(as.bits, as.offset, as.length, as.prefix, as.root, as.suffix) as any;
+export function mutableClone<A>(self: Vector<A>): MutableVector<A> {
+  return new Vector(self.bits, self.offset, self.length, self.prefix, self.root, self.suffix) as any;
 }
 
 /**
@@ -790,13 +857,15 @@ export function mutableClone<A>(as: Vector<A>): MutableVector<A> {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector modifyAt
+ * @tsplus pipeable fncts.Vector modifyAt
  */
-export function modifyAt_<A>(as: Vector<A>, i: number, f: (a: A) => A): Vector<A> {
-  if (i < 0 || as.length <= i) {
-    return as;
-  }
-  return as.updateAt(i, f(as.unsafeGet(i)!));
+export function modifyAt<A>(i: number, f: (a: A) => A) {
+  return (self: Vector<A>): Vector<A> => {
+    if (i < 0 || self.length <= i) {
+      return self;
+    }
+    return self.updateAt(i, f(self.unsafeGet(i)!));
+  };
 }
 
 /**
@@ -805,10 +874,12 @@ export function modifyAt_<A>(as: Vector<A>, i: number, f: (a: A) => A): Vector<A
  *
  * @complexity O(n)
  *
- * @tsplus fluent fncts.Vector none
+ * @tsplus pipeable fncts.Vector none
  */
-export function none_<A>(as: Vector<A>, predicate: Predicate<A>): boolean {
-  return !as.exists(predicate);
+export function none<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): boolean => {
+    return !self.some(predicate);
+  };
 }
 
 /**
@@ -828,8 +899,8 @@ export function pair<A>(first: A, second: A): Vector<A> {
  * @complexity `O(1)`
  * @tsplus getter fncts.Vector pop
  */
-export function pop<A>(as: Vector<A>): Vector<A> {
-  return as.slice(0, -1);
+export function pop<A>(self: Vector<A>): Vector<A> {
+  return self.slice(0, -1);
 }
 
 /**
@@ -837,35 +908,37 @@ export function pop<A>(as: Vector<A>): Vector<A> {
  *
  * @complexity O(1)
  *
- * @tsplus fluent fncts.Vector prepend
- */
-export function prepend_<A>(as: Vector<A>, a: A): Vector<A> {
-  const prefixSize = getPrefixSize(as);
-  if (prefixSize < 32) {
-    return new Vector<A>(
-      incrementPrefix(as.bits),
-      as.offset,
-      as.length + 1,
-      affixPush(a, as.prefix, prefixSize),
-      as.root,
-      as.suffix,
-    );
-  } else {
-    const newVector = mutableClone(as);
-    prependNodeToTree(newVector, reverseArray(as.prefix));
-    const newPrefix  = [a];
-    newVector.prefix = newPrefix;
-    newVector.length++;
-    newVector.bits = setPrefix(1, newVector.bits);
-    return newVector;
-  }
+ * @tsplus pipeable fncts.Vector prepend
+ */
+export function prepend<A>(a: A) {
+  return (self: Vector<A>): Vector<A> => {
+    const prefixSize = getPrefixSize(self);
+    if (prefixSize < 32) {
+      return new Vector<A>(
+        incrementPrefix(self.bits),
+        self.offset,
+        self.length + 1,
+        affixPush(a, self.prefix, prefixSize),
+        self.root,
+        self.suffix,
+      );
+    } else {
+      const newVector = mutableClone(self);
+      prependNodeToTree(newVector, reverseArray(self.prefix));
+      const newPrefix  = [a];
+      newVector.prefix = newPrefix;
+      newVector.length++;
+      newVector.bits = setPrefix(1, newVector.bits);
+      return newVector;
+    }
+  };
 }
 
 /**
  * @tsplus operator fncts.Vector +
  */
-export function prependOperator<A>(a: A, as: Vector<A>): Vector<A> {
-  return as.prepend(a);
+export function prependOperator<A>(a: A, self: Vector<A>): Vector<A> {
+  return self.prepend(a);
 }
 
 /**
@@ -889,10 +962,12 @@ export function range(start: number, end: number): Vector<number> {
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector remove
+ * @tsplus pipeable fncts.Vector remove
  */
-export function remove_<A>(as: Vector<A>, from: number, amount: number): Vector<A> {
-  return as.slice(0, from).concat(as.slice(from + amount, as.length));
+export function remove(from: number, amount: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    return self.slice(0, from).concat(self.slice(from + amount, self.length));
+  };
 }
 
 /**
@@ -922,10 +997,12 @@ export function reverse<A>(self: Vector<A>): Vector<A> {
  * 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_<A, B>(as: Vector<A>, initial: B, f: (acc: B, value: A) => B): Vector<B> {
-  return as.foldLeft(emptyPushable<B>().push(initial), (l2, a) => l2.push(f((l2 as Vector<B>).unsafeLast!, a)));
+export function scanLeft<A, B>(initial: B, f: (acc: B, value: A) => B) {
+  return (self: Vector<A>): Vector<B> => {
+    return self.foldLeft(emptyPushable<B>().push(initial), (l2, a) => l2.push(f((l2 as Vector<B>).unsafeLast!, a)));
+  };
 }
 
 /**
@@ -944,123 +1021,119 @@ export function single<A>(a: A): Vector<A> {
  * from the right end of the Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector slice
- */
-export function slice_<A>(as: Vector<A>, from: number, to: number): Vector<A> {
-  let { bits, length } = as;
-  let _to              = to;
-  let _from            = from;
-  _to                  = Math.min(length, to);
-  // Handle negative indices
-  if (_from < 0) {
-    _from = length + from;
-  }
-  if (_to < 0) {
-    _to = length + to;
-  }
-
-  // Should we just return the empty Vector?
-  if (_to <= _from || _to <= 0 || length <= _from) {
-    return empty();
-  }
-
-  // Return Vector unchanged if we are slicing nothing off
-  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
-  if (_to <= prefixSize) {
-    return new 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
-  if (suffixStart <= _from) {
-    return new Vector(
-      setSuffix(newLength, 0),
-      0,
-      newLength,
-      emptyAffix,
-      undefined,
-      as.suffix.slice(_from - suffixStart, _to - suffixStart),
-    );
-  }
-
-  const newVector  = mutableClone(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 (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);
+ * @tsplus pipeable fncts.Vector slice
+ */
+export function slice(from: number, to: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    let { bits, length } = self;
+    let _to              = to;
+    let _from            = from;
+    _to                  = Math.min(length, to);
+    // Handle negative indices
+    if (_from < 0) {
+      _from = length + from;
+    }
+    if (_to < 0) {
+      _to = length + to;
+    }
+    // Should we just return the empty Vector?
+    if (_to <= _from || _to <= 0 || length <= _from) {
+      return empty();
+    }
+    // Return Vector unchanged if we are slicing nothing off
+    if (_from <= 0 && length <= _to) {
+      return self;
+    }
+    const newLength  = _to - _from;
+    let prefixSize   = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
+    // Both indices lie in the prefix
+    if (_to <= prefixSize) {
+      return new Vector(
+        setPrefix(newLength, 0),
+        0,
+        newLength,
+        self.prefix.slice(prefixSize - _to, prefixSize - _from),
+        undefined,
+        emptyAffix,
+      );
+    }
+    const suffixStart = length - suffixSize;
+    // Both indices lie in the suffix
+    if (suffixStart <= _from) {
+      return new Vector(
+        setSuffix(newLength, 0),
+        0,
+        newLength,
+        emptyAffix,
+        undefined,
+        self.suffix.slice(_from - suffixStart, _to - suffixStart),
+      );
+    }
+    const newVector  = mutableClone(self);
+    newVector.length = newLength;
+    // Both indices lie in the tree
+    if (prefixSize <= _from && _to <= suffixStart) {
+      sliceTreeVector(
+        _from - prefixSize + self.offset,
+        _to - prefixSize + self.offset - 1,
+        self.root!,
+        getDepth(self),
+        self.offset,
+        newVector,
+      );
+      return newVector;
+    }
+    if (0 < _from) {
+      // we need _to slice something off of the left
+      if (_from < prefixSize) {
+        // shorten the prefix even though it's not strictly needed,
+        // so that referenced items can be GC'd
+        newVector.prefix = self.prefix.slice(0, prefixSize - _from);
+        bits             = 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(self), _from - prefixSize, self.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
-      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 (_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 = self.suffix.slice(0, suffixSize - (length - _to));
+      } else {
+        newVector.root = sliceRight(newVector.root!, getDepth(self), _to - prefixSize - 1, newVector.offset);
+        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_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector<A> {
-  return self.sortWith(O.compare);
+export function sort<A>(/** @tsplus auto */ O: Ord<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    return self.sortWith((a, b) => O.compare(b)(a));
+  };
 }
 
 /**
@@ -1072,21 +1145,26 @@ export function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector
  *
  * @complexity O(n * log(n))
  *
- * @tsplus fluent fncts.Vector sortWith
- */
-export function sortWith_<A>(as: Vector<A>, compare: (a: A, b: A) => Ordering): Vector<A> {
-  const arr: { idx: number; elm: A }[] = [];
-  let i = 0;
-  as.forEach((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<A>();
-  for (let i = 0; i < arr.length; ++i) {
-    newL.push(arr[i]!.elm);
-  }
-  return newL;
+ * @tsplus pipeable fncts.Vector sortWith
+ */
+export function sortWith<A>(compare: (a: A, b: A) => Ordering) {
+  return (self: Vector<A>): Vector<A> => {
+    const arr: {
+      idx: number;
+      elm: A;
+    }[] = [];
+    let i = 0;
+    self.forEach((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<A>();
+    for (let i = 0; i < arr.length; ++i) {
+      newL.push(arr[i]!.elm);
+    }
+    return newL;
+  };
 }
 
 /**
@@ -1097,10 +1175,12 @@ export function sortWith_<A>(as: Vector<A>, compare: (a: A, b: A) => Ordering):
  *
  * @complexity `O(log(n))`
  *
- * @tsplus fluent fncts.Vector splitAt
+ * @tsplus pipeable fncts.Vector splitAt
  */
-export function splitAt_<A>(as: Vector<A>, index: number): [Vector<A>, Vector<A>] {
-  return [as.slice(0, index), as.slice(index, as.length)];
+export function splitAt(index: number) {
+  return <A>(self: Vector<A>): [Vector<A>, Vector<A>] => {
+    return [self.slice(0, index), self.slice(index, self.length)];
+  };
 }
 
 /**
@@ -1109,11 +1189,13 @@ export function splitAt_<A>(as: Vector<A>, index: number): [Vector<A>, Vector<A>
  *
  * @complexity `O(n)`
  *
- * @tsplus fluent fncts.Vector splitWhen
+ * @tsplus pipeable fncts.Vector splitWhen
  */
-export function splitWhen_<A>(as: Vector<A>, predicate: Predicate<A>): [Vector<A>, Vector<A>] {
-  const idx = as.findIndex(predicate);
-  return idx === -1 ? [as, Vector.empty()] : as.splitAt(idx);
+export function splitWhen<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): [Vector<A>, Vector<A>] => {
+    const idx = self.findIndex(predicate);
+    return idx === -1 ? [self, Vector.empty()] : self.splitAt(idx);
+  };
 }
 
 /**
@@ -1124,18 +1206,20 @@ export function splitWhen_<A>(as: Vector<A>, predicate: Predicate<A>): [Vector<A
  *
  * @tsplus getter fncts.Vector tail
  */
-export function tail<A>(as: Vector<A>): Vector<A> {
-  return as.slice(1, as.length);
+export function tail<A>(self: Vector<A>): Vector<A> {
+  return self.slice(1, self.length);
 }
 
 /**
  * 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_<A>(as: Vector<A>, n: number): Vector<A> {
-  return as.slice(0, n);
+export function take(n: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    return self.slice(0, n);
+  };
 }
 
 /**
@@ -1145,11 +1229,13 @@ export function take_<A>(as: Vector<A>, n: number): Vector<A> {
  * @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_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A> {
-  const { index } = foldLeftCb(findNotIndexCb, { predicate, index: 0 }, as);
-  return as.slice(0, index);
+export function takeWhile<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    const { index } = foldLeftCb(findNotIndexCb, { predicate, index: 0 }, self);
+    return self.slice(0, index);
+  };
 }
 
 /**
@@ -1157,10 +1243,12 @@ export function takeWhile_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A>
  * Vector.
  *
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector takeLast
+ * @tsplus pipeable fncts.Vector takeLast
  */
-export function takeLast_<A>(as: Vector<A>, n: number): Vector<A> {
-  return as.slice(as.length - n, as.length);
+export function takeLast(n: number) {
+  return <A>(self: Vector<A>): Vector<A> => {
+    return self.slice(self.length - n, self.length);
+  };
 }
 
 /**
@@ -1170,11 +1258,13 @@ export function takeLast_<A>(as: Vector<A>, n: number): Vector<A> {
  * @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_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A> {
-  const { index } = foldRightCb(findNotIndexCb, { predicate, index: 0 }, as);
-  return as.slice(as.length - index, as.length);
+export function takeLastWhile<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): Vector<A> => {
+    const { index } = foldRightCb(findNotIndexCb, { predicate, index: 0 }, self);
+    return self.slice(self.length - index, self.length);
+  };
 }
 
 /**
@@ -1204,19 +1294,42 @@ export function toList<A>(self: Vector<A>): List<A> {
 /**
  * @tsplus getter fncts.Vector traverseWithIndex
  */
-export const traverseWithIndex = TraversableWithIndex.makeTraverseWithIndex<VectorF>()(() => (self) => (G) => (f) => {
-  return self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
-    G.zipWith(b, f(i, a), (v, b) => {
-      push(v, b);
-      return v;
-    }),
-  );
-});
+export function _traverseWithIndex<A>(
+  self: Vector<A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K, Q, W, X, I, S, R, E, B>(
+  f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>,
+) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Vector<B>>;
+export function _traverseWithIndex<A>(
+  self: Vector<A>,
+): <G>(G: P.Applicative<HKT.F<G>>) => <B>(f: (i: number, a: A) => HKT.FK1<G, B>) => HKT.FK1<G, Vector<B>> {
+  return (G) => (f) =>
+    self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
+      b.pipe(
+        G.zipWith(f(i, a), (v, b) => {
+          v.push(b);
+          return v;
+        }),
+      ),
+    );
+}
 
 /**
  * @tsplus getter fncts.Vector traverse
  */
-export const traverse: Traversable<VectorF>["traverse"] = (self) => (G) => (f) =>
+export function _traverse<A>(self: Vector<A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E, B>(
+      f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Vector<B>> =>
+      self.traverseWithIndex(G)((_, a) => f(a));
+}
+
+export const traverseWithIndex: P.TraversableWithIndex<VectorF>["traverseWithIndex"] = (G) => (f) => (self) =>
+  self.traverseWithIndex(G)(f);
+
+export const traverse: Traversable<VectorF>["traverse"] = (G) => (f) => (self) =>
   self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
@@ -1224,10 +1337,10 @@ export const traverse: Traversable<VectorF>["traverse"] = (self) => (G) => (f) =
  * Eq instance to determine when elements are equal
  *
  * @complexity `O(n)`
- * @tsplus getter fncts.Vector uniq
+ * @tsplus pipeable fncts.Vector uniq
  */
-export function uniq<A>(as: Vector<A>) {
-  return (E: Eq<A>) => as.dropRepeatsWith(E.equals);
+export function uniq<A>(E: Eq<A>) {
+  return (self: Vector<A>) => self.dropRepeatsWith((a, b) => E.equals(b)(a));
 }
 
 /**
@@ -1264,10 +1377,12 @@ function findCb<A>(value: A, state: PredState): boolean {
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFind
+ * @tsplus pipeable fncts.Vector unsafeFind
  */
-export function unsafeFind_<A>(as: Vector<A>, predicate: Predicate<A>): A | undefined {
-  return foldLeftCb<A, PredState>(findCb, { predicate, result: undefined }, as).result;
+export function unsafeFind<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): A | undefined => {
+    return foldLeftCb<A, PredState>(findCb, { predicate, result: undefined }, self).result;
+  };
 }
 
 /**
@@ -1275,10 +1390,12 @@ export function unsafeFind_<A>(as: Vector<A>, predicate: Predicate<A>): A | unde
  * If no such element is found the function returns `undefined`.
  *
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFindLast
+ * @tsplus pipeable fncts.Vector unsafeFindLast
  */
-export function unsafeFindLast_<A>(as: Vector<A>, predicate: Predicate<A>): A | undefined {
-  return foldRightCb<A, PredState>(findCb, { predicate, result: undefined }, as).result;
+export function unsafeFindLast<A>(predicate: Predicate<A>) {
+  return (self: Vector<A>): A | undefined => {
+    return foldRightCb<A, PredState>(findCb, { predicate, result: undefined }, self).result;
+  };
 }
 
 /**
@@ -1286,24 +1403,31 @@ export function unsafeFindLast_<A>(as: Vector<A>, predicate: Predicate<A>): A |
  * `undefined` is returned.
  *
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector unsafeGet
+ * @tsplus pipeable fncts.Vector unsafeGet
+ * @tsplus pipeable-index fncts.Vector
  */
-export function unsafeGet_<A>(l: Vector<A>, index: number): A | undefined {
-  if (index < 0 || l.length <= index) {
-    return undefined;
-  }
-  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)];
-  }
-  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);
+export function unsafeGet(index: number) {
+  return <A>(self: Vector<A>): A | undefined => {
+    if (index < 0 || self.length <= index) {
+      return undefined;
+    }
+    const prefixSize = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
+    if (index < prefixSize) {
+      return self.prefix[prefixSize - index - 1];
+    } else if (index >= self.length - suffixSize) {
+      return self.suffix[index - (self.length - suffixSize)];
+    }
+    const { offset } = self;
+    const depth      = getDepth(self);
+    return self.root!.sizes === undefined
+      ? nodeNthDense(
+          self.root!,
+          depth,
+          offset === 0 ? index - prefixSize : handleOffset(depth, offset, index - prefixSize),
+        )
+      : nodeNth(self.root!, depth, offset, index - prefixSize);
+  };
 }
 
 /**
@@ -1313,9 +1437,9 @@ export function unsafeGet_<A>(l: Vector<A>, index: number): A | undefined {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeHead
  */
-export function unsafeHead<A>(l: Vector<A>): A | undefined {
-  const prefixSize = getPrefixSize(l);
-  return prefixSize !== 0 ? l.prefix[prefixSize - 1] : l.length !== 0 ? l.suffix[0] : undefined;
+export function unsafeHead<A>(self: Vector<A>): A | undefined {
+  const prefixSize = getPrefixSize(self);
+  return prefixSize !== 0 ? self.prefix[prefixSize - 1] : self.length !== 0 ? self.suffix[0] : undefined;
 }
 
 /**
@@ -1325,9 +1449,9 @@ export function unsafeHead<A>(l: Vector<A>): A | undefined {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeLast
  */
-export function unsafeLast<A>(l: Vector<A>): A | undefined {
-  const suffixSize = getSuffixSize(l);
-  return suffixSize !== 0 ? l.suffix[suffixSize - 1] : l.length !== 0 ? l.prefix[0] : undefined;
+export function unsafeLast<A>(self: Vector<A>): A | undefined {
+  const suffixSize = getSuffixSize(self);
+  return suffixSize !== 0 ? self.suffix[suffixSize - 1] : self.length !== 0 ? self.prefix[0] : undefined;
 }
 
 /**
@@ -1336,27 +1460,29 @@ export function unsafeLast<A>(l: Vector<A>): A | undefined {
  * 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
  */
-export function updateAt_<A>(as: Vector<A>, i: number, a: A): Vector<A> {
-  if (i < 0 || as.length <= i) {
-    return as;
-  }
-  const prefixSize = getPrefixSize(as);
-  const suffixSize = getSuffixSize(as);
-  const newVector  = mutableClone(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);
-  }
-  return newVector;
+export function updateAt<A>(i: number, a: A) {
+  return (self: Vector<A>): Vector<A> => {
+    if (i < 0 || self.length <= i) {
+      return self;
+    }
+    const prefixSize = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
+    const newVector  = mutableClone(self);
+    if (i < prefixSize) {
+      const newPrefix                     = copyArray(newVector.prefix);
+      newPrefix[newPrefix.length - i - 1] = a;
+      newVector.prefix                    = newPrefix;
+    } else if (i >= self.length - suffixSize) {
+      const newSuffix = copyArray(newVector.suffix);
+      newSuffix[i - (self.length - suffixSize)] = a;
+      newVector.suffix = newSuffix;
+    } else {
+      newVector.root = updateNode(self.root!, getDepth(self), i - prefixSize, self.offset, a);
+    }
+    return newVector;
+  };
 }
 
 /**