@fncts/base 0.0.21 → 0.0.23

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

@@ -1,6 +1,6 @@
 import * as tsplus_module_1 from "@fncts/base/collection/immutable/Vector";
 import * as tsplus_module_2 from "@fncts/base/collection/immutable/Vector/internal";
-import * as tsplus_module_3 from "@fncts/base/typeclass/Equatable/api";
+import * as tsplus_module_3 from "@fncts/base/data/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";
@@ -10,7 +10,7 @@ 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 some = some_1;
 export const findIndex = findIndex_1;
 export const flatten = flatten_1;
 export const foldLeft = foldLeft_1;
@@ -43,18 +43,15 @@ import { affixPush, appendNodeToTree, arrayPush, branchBits, concatAffixes, conc
  * @tsplus pipeable fncts.Vector append
  * @tsplus pipeable-operator fncts.Vector +
  */
-
 function append_1(a) {
-  return as => {
-    const suffixSize = getSuffixSize(as);
-
+  return self => {
+    const suffixSize = getSuffixSize(self);
     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));
+      return new tsplus_module_1.Vector(incrementSuffix(self.bits), self.offset, self.length + 1, self.prefix, self.root, affixPush(a, self.suffix, suffixSize));
     }
-
     const newSuffix = [a];
-    const newVector = mutableClone_1(as);
-    appendNodeToTree(newVector, as.suffix);
+    const newVector = mutableClone_1(self);
+    appendNodeToTree(newVector, self.suffix);
     newVector.suffix = newSuffix;
     newVector.length++;
     newVector.bits = setSuffix(1, newVector.bits);
@@ -67,11 +64,9 @@ function append_1(a) {
  *
  * @tsplus pipeable fncts.Vector flatMap
  */
-
-
 export function flatMap(f) {
-  return ma => {
-    return flatten_1(map_1(f)(ma));
+  return self => {
+    return flatten_1(map_1(f)(self));
   };
 }
 /**
@@ -79,9 +74,8 @@ export function flatMap(f) {
  *
  * @tsplus pipeable fncts.Vector chunksOf
  */
-
 export function chunksOf(size) {
-  return as => {
+  return self => {
     const {
       buffer,
       l2
@@ -93,7 +87,6 @@ export function chunksOf(size) {
       l2
     }, elem) => {
       tsplus_module_2.push(elem)(buffer);
-
       if (buffer.length === size) {
         return {
           l2: tsplus_module_2.push(buffer)(l2),
@@ -105,11 +98,10 @@ export function chunksOf(size) {
           buffer
         };
       }
-    })(as);
+    })(self);
     return buffer.length === 0 ? l2 : tsplus_module_2.push(buffer)(l2);
   };
 }
-
 function concat_1(that) {
   return self => {
     if (self.length === 0) {
@@ -117,22 +109,18 @@ function concat_1(that) {
     } else if (that.length === 0) {
       return 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);
-
       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
-
+        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);
@@ -140,12 +128,10 @@ function concat_1(that) {
       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);
@@ -159,12 +145,10 @@ function concat_1(that) {
     }
   };
 }
-
 const containsState = {
   element: undefined,
   result: false
 };
-
 function containsCb(value, state) {
   return !(state.result = value === state.element);
 }
@@ -175,13 +159,11 @@ function containsCb(value, state) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector contains
  */
-
-
 export function contains(element) {
-  return as => {
+  return self => {
     containsState.element = element;
     containsState.result = false;
-    return foldLeftCb(containsCb, containsState, as).result;
+    return foldLeftCb(containsCb, containsState, self).result;
   };
 }
 /**
@@ -190,10 +172,9 @@ export function contains(element) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector drop
  */
-
 export function drop(n) {
-  return as => {
-    return slice_1(n, as.length)(as);
+  return self => {
+    return slice_1(n, self.length)(self);
   };
 }
 /**
@@ -202,10 +183,9 @@ export function drop(n) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector dropLast
  */
-
 export function dropLast(n) {
-  return as => {
-    return slice_1(0, as.length - n)(as);
+  return self => {
+    return slice_1(0, self.length - n)(self);
   };
 }
 /**
@@ -214,9 +194,8 @@ export function dropLast(n) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector dropRepeats
  */
-
-export function dropRepeats(as) {
-  return dropRepeatsWith_1(tsplus_module_3.strictEquals)(as);
+export function dropRepeats(self) {
+  return dropRepeatsWith_1(tsplus_module_3.strictEquals)(self);
 }
 /**
  * Returns a new Vector without repeated elements by using the given
@@ -225,13 +204,11 @@ export function dropRepeats(as) {
  * @complexity `O(n)`
  * @tsplus pipeable fncts.Vector dropRepeatsWith
  */
-
 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);
+  return self => {
+    return foldLeft_1(emptyPushable_1(), (acc, a) => acc.length !== 0 && predicate(unsafeLast_1(acc), a) ? acc : tsplus_module_2.push(a)(acc))(self);
   };
 }
-
 function findNotIndexCb(value, state) {
   if (state.predicate(value)) {
     ++state.index;
@@ -248,31 +225,24 @@ function findNotIndexCb(value, state) {
  * satisfying the predicate.
  * @tsplus pipeable fncts.Vector dropWhile
  */
-
-
 export function dropWhile(predicate) {
-  return as => {
+  return self => {
     const {
       index
     } = foldLeftCb(findNotIndexCb, {
       predicate,
       index: 0
-    }, as);
-    return slice_1(index, as.length)(as);
+    }, self);
+    return slice_1(index, self.length)(self);
   };
 }
-
 function elemCb(value, state) {
-  return !(state.result = state.equals(value, state.element));
+  return !(state.result = state.equals(state.element)(value));
 }
 /**
  * @tsplus pipeable fncts.Vector elem
  */
-
-
-export function elem(a,
-/** @tsplus auto */
-E) {
+export function elem(a, /** @tsplus auto */E) {
   const elemState = {
     equals: E.equals,
     element: undefined,
@@ -289,23 +259,20 @@ E) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector equals
  */
-
 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(predicate) {
-  return as => {
+  return self => {
     return foldLeftCb(everyCb, {
       predicate,
       result: true
-    }, as).result;
+    }, self).result;
   };
 }
 /**
@@ -314,20 +281,16 @@ export function every(predicate) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps empty
  */
-
 function empty_1() {
   return new tsplus_module_1.Vector(0, 0, 0, emptyAffix, undefined, emptyAffix);
 }
 /**
  * @tsplus static fncts.VectorOps emptyPushable
  */
-
-
 function emptyPushable_1() {
   return new tsplus_module_1.Vector(0, 0, 0, [], undefined, []);
 }
-
-function existsCb(value, state) {
+function someCb(value, state) {
   return !(state.result = state.predicate(value));
 }
 /**
@@ -336,16 +299,14 @@ function existsCb(value, state) {
  *
  * @complexity O(n)
  *
- * @tsplus pipeable fncts.Vector exists
+ * @tsplus pipeable fncts.Vector some
  */
-
-
-function exists_1(predicate) {
-  return as => {
-    return foldLeftCb(existsCb, {
+function some_1(predicate) {
+  return self => {
+    return foldLeftCb(someCb, {
       predicate,
       result: false
-    }, as).result;
+    }, self).result;
   };
 }
 /**
@@ -355,14 +316,11 @@ function exists_1(predicate) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector find
  */
-
-
 export function find(predicate) {
-  return as => {
-    return tsplus_module_5.fromNullable(unsafeFind_1(predicate)(as));
+  return self => {
+    return tsplus_module_5.fromNullable(unsafeFind_1(predicate)(self));
   };
 }
-
 function findIndexCb(value, state) {
   ++state.index;
   return !(state.found = state.predicate(value));
@@ -375,10 +333,8 @@ function findIndexCb(value, state) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector findIndex
  */
-
-
 function findIndex_1(predicate) {
-  return as => {
+  return self => {
     const {
       found,
       index
@@ -386,7 +342,7 @@ function findIndex_1(predicate) {
       predicate,
       found: false,
       index: -1
-    }, as);
+    }, self);
     return found ? index : -1;
   };
 }
@@ -397,11 +353,9 @@ function findIndex_1(predicate) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector findLast
  */
-
-
 export function findLast(predicate) {
-  return as => {
-    return tsplus_module_5.fromNullable(unsafeFindLast_1(predicate)(as));
+  return self => {
+    return tsplus_module_5.fromNullable(unsafeFindLast_1(predicate)(self));
   };
 }
 /**
@@ -412,9 +366,8 @@ export function findLast(predicate) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector findLastIndex
  */
-
 export function findLastIndex(predicate) {
-  return as => {
+  return self => {
     const {
       found,
       index
@@ -422,7 +375,7 @@ export function findLastIndex(predicate) {
       predicate,
       found: false,
       index: -0
-    }, as);
+    }, self);
     return found ? index : -1;
   };
 }
@@ -434,14 +387,11 @@ export function findLastIndex(predicate) {
  *
  * @tsplus getter fncts.Vector flatten
  */
-
-function flatten_1(mma) {
-  return foldLeft_1(empty_1(), (acc, a) => concat_1(a)(acc))(mma);
+function flatten_1(self) {
+  return foldLeft_1(empty_1(), (acc, a) => concat_1(a)(acc))(self);
 }
-
 export function from(sequence) {
   const l = emptyPushable_1();
-
   if (sequence.length > 0 && (sequence[0] !== undefined || 0 in sequence)) {
     for (let i = 0; i < sequence.length; ++i) {
       tsplus_module_2.push(sequence[i])(l);
@@ -449,12 +399,10 @@ export function from(sequence) {
   } else if (Symbol.iterator in sequence) {
     const iterator = sequence[Symbol.iterator]();
     let cur;
-
     while (!(cur = iterator.next()).done) {
       tsplus_module_2.push(cur.value)(l);
     }
   }
-
   return l;
 }
 /**
@@ -462,28 +410,23 @@ export function from(sequence) {
  *
  * @tsplus pipeable fncts.Vector foldLeft
  */
-
 function foldLeft_1(initial, f) {
-  return fa => {
-    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(fa);
+  return self => {
+    return foldLeftWithIndex_1(initial, (_, b, a) => f(b, a))(self);
   };
 }
 /**
  * @tsplus pipeable fncts.Vector foldLeftWithIndex
  */
-
-
 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);
+  return self => {
+    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, fa.suffix, suffixSize, index)[0];
+    return foldLeftSuffix(f, acc, self.suffix, suffixSize, index)[0];
   };
 }
 /**
@@ -500,54 +443,44 @@ function foldLeftWithIndex_1(b, f) {
  * const ys = V.vector(2, 4, 6);
  * foldlWhile(isOdd, (n, m) => n + m, 111, ys) //=> 111
  */
-
-
 function foldWhileCb(a, state, i) {
   if (state.predicate(state.result) === false) {
     return false;
   }
-
   state.result = state.f(i, state.result, a);
   return true;
 }
 /**
  * @tsplus pipeable fncts.Vector foldLeftWhile
  */
-
-
 export function foldLeftWhile(b, cont, f) {
-  return fa => {
+  return self => {
     if (!cont(b)) {
       return b;
     }
-
     return foldLeftCb(foldWhileCb, {
       predicate: cont,
       f,
       result: b
-    }, fa).result;
+    }, self).result;
   };
 }
 /**
  * @tsplus pipeable fncts.Vector foldRightWhile
  */
-
 export function foldRightWhile(b, cont, f) {
-  return fa => {
+  return self => {
     return foldRightCb(foldWhileCb, {
       predicate: cont,
       result: b,
       f: (i, b, a) => f(i, a, b)
-    }, fa).result;
+    }, self).result;
   };
 }
 /**
  * @tsplus pipeable fncts.Vector foldMap
  */
-
-export function foldMap(f,
-/** @tsplus auto */
-M) {
+export function foldMap(f, /** @tsplus auto */M) {
   return self => {
     return foldMapWithIndex_1((_, a) => f(a), M)(self);
   };
@@ -555,12 +488,9 @@ M) {
 /**
  * @tsplus pipeable fncts.Vector foldMapWithIndex
  */
-
-function foldMapWithIndex_1(f,
-/** @tsplus auto */
-M) {
+function foldMapWithIndex_1(f, /** @tsplus auto */M) {
   return self => {
-    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(b, f(i, a)))(self);
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(f(i, a))(b))(self);
   };
 }
 /**
@@ -569,11 +499,9 @@ M) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector foldRight
  */
-
-
 export function foldRight(initial, f) {
-  return fa => {
-    return foldRightWithIndex_1(initial, (_, a, b) => f(a, b))(fa);
+  return self => {
+    return foldRightWithIndex_1(initial, (_, a, b) => f(a, b))(self);
   };
 }
 /**
@@ -582,18 +510,15 @@ export function foldRight(initial, f) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector foldRightWithIndex
  */
-
 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);
+  return self => {
+    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, fa.prefix, prefixSize, j)[0];
+    return foldRightPrefix(f, acc, self.prefix, prefixSize, j)[0];
   };
 }
 /**
@@ -608,21 +533,17 @@ function foldRightWithIndex_1(b, f) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector forEach
  */
-
-
 function forEach_1(f) {
-  return as => {
-    foldLeft_1(undefined, (_, element) => f(element))(as);
+  return self => {
+    foldLeft_1(undefined, (_, element) => f(element))(self);
   };
 }
 /**
  * @tsplus pipeable fncts.Vector forEachWithIndex
  */
-
-
 export function forEachWithIndex(f) {
-  return as => {
-    foldLeftWithIndex_1(undefined, (index, _, element) => f(index, element))(as);
+  return self => {
+    foldLeftWithIndex_1(undefined, (index, _, element) => f(index, element))(self);
   };
 }
 /**
@@ -632,7 +553,6 @@ export function forEachWithIndex(f) {
  * @complexity O(log(n))
  * @tsplus pipeable fncts.Vector get
  */
-
 export function get(index) {
   return self => {
     return tsplus_module_5.fromNullable(unsafeGet_1(index)(self));
@@ -648,9 +568,8 @@ export function get(index) {
  *
  * @tsplus pipeable fncts.Vector groupWith
  */
-
 export function groupWith(f) {
-  return as => {
+  return self => {
     const result = emptyPushable_1();
     let buffer = emptyPushable_1();
     forEach_1(a => {
@@ -658,9 +577,8 @@ export function groupWith(f) {
         tsplus_module_2.push(buffer)(result);
         buffer = emptyPushable_1();
       }
-
       tsplus_module_2.push(a)(buffer);
-    })(as);
+    })(self);
     return buffer.length === 0 ? result : tsplus_module_2.push(buffer)(result);
   };
 }
@@ -670,11 +588,9 @@ export function groupWith(f) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector head
  */
-
 export function head(self) {
   return tsplus_module_5.fromNullable(unsafeHead_1(self));
 }
-
 function indexOfCb(value, state) {
   ++state.index;
   return !(state.found = tsplus_module_3.strictEquals(value, state.element));
@@ -686,16 +602,14 @@ function indexOfCb(value, state) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector indexOf
  */
-
-
 export function indexOf(element) {
-  return as => {
+  return self => {
     const state = {
       element,
       found: false,
       index: -1
     };
-    foldLeftCb(indexOfCb, state, as);
+    foldLeftCb(indexOfCb, state, self);
     return state.found ? state.index : -1;
   };
 }
@@ -705,10 +619,9 @@ export function indexOf(element) {
  * @complexity O(log(n))
  * @tsplus pipeable fncts.Vector insertAt
  */
-
 export function insertAt(index, element) {
-  return as => {
-    return concat_1(slice_1(index, as.length)(as))(append_1(element)(slice_1(0, index)(as)));
+  return self => {
+    return concat_1(slice_1(index, self.length)(self))(append_1(element)(slice_1(0, index)(self)));
   };
 }
 /**
@@ -717,10 +630,9 @@ export function insertAt(index, element) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector insertAllAt
  */
-
 export function insertAllAt(index, elements) {
-  return as => {
-    return concat_1(slice_1(index, as.length)(as))(concat_1(elements)(slice_1(0, index)(as)));
+  return self => {
+    return concat_1(slice_1(index, self.length)(self))(concat_1(elements)(slice_1(0, index)(self)));
   };
 }
 /**
@@ -728,35 +640,31 @@ export function insertAllAt(index, elements) {
  *
  * @tsplus pipeable fncts.Vector intersperse
  */
-
 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));
+  return self => {
+    return pop_1(foldLeft_1(emptyPushable_1(), (l2, a) => tsplus_module_2.push(separator)(tsplus_module_2.push(a)(l2)))(self));
   };
 }
 /**
  * @tsplus fluent fncts.Vector isEmpty
  */
-
-export function isEmpty(l) {
-  return l.length === 0;
+export function isEmpty(self) {
+  return self.length === 0;
 }
 /**
  * @tsplus fluent fncts.Vector isNonEmpty
  */
-
-export function isNonEmpty(l) {
-  return l.length > 0;
+export function isNonEmpty(self) {
+  return self.length > 0;
 }
 /**
  * Concatenates the strings in the Vector separated by a specified separator.
  *
  * @tsplus pipeable fncts.Vector join
  */
-
 export function join(separator) {
-  return as => {
-    return foldLeft_1("", (a, b) => a.length === 0 ? b : a + separator + b)(as);
+  return self => {
+    return foldLeft_1("", (a, b) => a.length === 0 ? b : a + separator + b)(self);
   };
 }
 /**
@@ -765,9 +673,8 @@ export function join(separator) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector last
  */
-
-export function last(l) {
-  return tsplus_module_5.fromNullable(unsafeLast_1(l));
+export function last(self) {
+  return tsplus_module_5.fromNullable(unsafeLast_1(self));
 }
 /**
  * Returns the index of the _last_ element in the Vector that is equal
@@ -776,16 +683,15 @@ export function last(l) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector lastIndexOf
  */
-
 export function lastIndexOf(element) {
-  return as => {
+  return self => {
     const state = {
       element,
       found: false,
       index: 0
     };
-    foldRightCb(indexOfCb, state, as);
-    return state.found ? as.length - state.index : -1;
+    foldRightCb(indexOfCb, state, self);
+    return state.found ? self.length - state.index : -1;
   };
 }
 /**
@@ -795,27 +701,23 @@ export function lastIndexOf(element) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps makeBy
  */
-
 export function makeBy(n, f) {
   const l = emptyPushable_1();
-
   for (let i = 0; i < n; i++) {
     tsplus_module_2.push(f(i))(l);
   }
-
   return l;
 }
 /**
  * @tsplus pipeable fncts.Vector mapAccum
  */
-
 export function mapAccum(s, f) {
-  return fa => {
+  return self => {
     return foldLeft_1([emptyPushable_1(), s], ([acc, s], a) => {
       const r = f(s, a);
       tsplus_module_2.push(r[0])(acc);
       return [acc, r[1]];
-    })(fa);
+    })(self);
   };
 }
 /**
@@ -825,10 +727,9 @@ export function mapAccum(s, f) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector map
  */
-
 function map_1(f) {
-  return fa => {
-    return mapWithIndex_1((_, a) => f(a))(fa);
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
   };
 }
 /**
@@ -838,20 +739,16 @@ function map_1(f) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector mapWithIndex
  */
-
-
 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));
+  return self => {
+    return new tsplus_module_1.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
  */
-
-
-function mutableClone_1(as) {
-  return new tsplus_module_1.Vector(as.bits, as.offset, as.length, as.prefix, as.root, as.suffix);
+function mutableClone_1(self) {
+  return new tsplus_module_1.Vector(self.bits, self.offset, self.length, self.prefix, self.root, self.suffix);
 }
 /**
  * Returns a Vector that has the entry specified by the index replaced with
@@ -864,15 +761,12 @@ function mutableClone_1(as) {
  *
  * @tsplus pipeable fncts.Vector modifyAt
  */
-
-
 export function modifyAt(i, f) {
-  return as => {
-    if (i < 0 || as.length <= i) {
-      return as;
+  return self => {
+    if (i < 0 || self.length <= i) {
+      return self;
     }
-
-    return updateAt_1(i, f(unsafeGet_1(i)(as)))(as);
+    return updateAt_1(i, f(unsafeGet_1(i)(self)))(self);
   };
 }
 /**
@@ -883,10 +777,9 @@ export function modifyAt(i, f) {
  *
  * @tsplus pipeable fncts.Vector none
  */
-
 export function none(predicate) {
-  return as => {
-    return !exists_1(predicate)(as);
+  return self => {
+    return !some_1(predicate)(self);
   };
 }
 /**
@@ -895,7 +788,6 @@ export function none(predicate) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps pair
  */
-
 export function pair(first, second) {
   return new tsplus_module_1.Vector(2, 0, 2, emptyAffix, undefined, [first, second]);
 }
@@ -906,9 +798,8 @@ export function pair(first, second) {
  * @complexity `O(1)`
  * @tsplus getter fncts.Vector pop
  */
-
-function pop_1(as) {
-  return slice_1(0, -1)(as);
+function pop_1(self) {
+  return slice_1(0, -1)(self);
 }
 /**
  * Prepends an element to the front of a Vector and returns the new Vector.
@@ -917,17 +808,14 @@ function pop_1(as) {
  *
  * @tsplus pipeable fncts.Vector prepend
  */
-
-
 function prepend_1(a) {
-  return as => {
-    const prefixSize = getPrefixSize(as);
-
+  return self => {
+    const prefixSize = getPrefixSize(self);
     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);
+      return new tsplus_module_1.Vector(incrementPrefix(self.bits), self.offset, self.length + 1, affixPush(a, self.prefix, prefixSize), self.root, self.suffix);
     } else {
-      const newVector = mutableClone_1(as);
-      prependNodeToTree(newVector, reverseArray(as.prefix));
+      const newVector = mutableClone_1(self);
+      prependNodeToTree(newVector, reverseArray(self.prefix));
       const newPrefix = [a];
       newVector.prefix = newPrefix;
       newVector.length++;
@@ -939,10 +827,8 @@ function prepend_1(a) {
 /**
  * @tsplus operator fncts.Vector +
  */
-
-
-export function prependOperator(a, as) {
-  return prepend_1(a)(as);
+export function prependOperator(a, self) {
+  return prepend_1(a)(self);
 }
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
@@ -950,14 +836,11 @@ export function prependOperator(a, as) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps range
  */
-
 export function range(start, end) {
   const vec = emptyPushable_1();
-
   for (let i = start; i < end; ++i) {
     tsplus_module_2.push(i)(vec);
   }
-
   return vec;
 }
 /**
@@ -969,10 +852,9 @@ export function range(start, end) {
  *
  * @tsplus pipeable fncts.Vector remove
  */
-
 export function remove(from, amount) {
-  return as => {
-    return concat_1(slice_1(from + amount, as.length)(as))(slice_1(0, from)(as));
+  return self => {
+    return concat_1(slice_1(from + amount, self.length)(self))(slice_1(0, from)(self));
   };
 }
 /**
@@ -982,21 +864,17 @@ export function remove(from, amount) {
  * @complexity O(n)
  * @tsplus static fncts.VectorOps replicate
  */
-
 export function replicate(n, a) {
   let t = n;
   const l = emptyPushable_1();
-
   while (--t >= 0) {
     tsplus_module_2.push(a)(l);
   }
-
   return l;
 }
 /**
  * @tsplus getter fncts.Vector reverse
  */
-
 export function reverse(self) {
   return foldLeft_1(empty_1(), (vec, elem) => prepend_1(elem)(vec))(self);
 }
@@ -1006,10 +884,9 @@ export function reverse(self) {
  *
  * @tsplus pipeable fncts.Vector scanLeft
  */
-
 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);
+  return self => {
+    return foldLeft_1(tsplus_module_2.push(initial)(emptyPushable_1()), (l2, a) => tsplus_module_2.push(f(unsafeLast_1(l2), a))(l2))(self);
   };
 }
 /**
@@ -1018,7 +895,6 @@ export function scanLeft(initial, f) {
  * @complexity O(1)
  * @tsplus static fncts.VectorOps single
  */
-
 export function single(a) {
   return vector_1(a);
 }
@@ -1030,101 +906,87 @@ export function single(a) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector slice
  */
-
 function slice_1(from, to) {
-  return as => {
+  return self => {
     let {
       bits,
       length
-    } = as;
+    } = self;
     let _to = to;
     let _from = from;
-    _to = Math.min(length, to); // Handle negative indices
-
+    _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?
-
-
+    }
+    // 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
-
-
+    }
+    // Return Vector unchanged if we are slicing nothing off
     if (_from <= 0 && length <= _to) {
-      return as;
+      return self;
     }
-
     const newLength = _to - _from;
-    let prefixSize = getPrefixSize(as);
-    const suffixSize = getSuffixSize(as); // Both indices lie in the prefix
-
+    let prefixSize = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
+    // 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);
+      return new tsplus_module_1.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
-
+    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));
+      return new tsplus_module_1.Vector(setSuffix(newLength, 0), 0, newLength, emptyAffix, undefined, self.suffix.slice(_from - suffixStart, _to - suffixStart));
     }
-
-    const newVector = mutableClone_1(as);
-    newVector.length = newLength; // Both indices lie in the tree
-
+    const newVector = mutableClone_1(self);
+    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);
+      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 = as.prefix.slice(0, prefixSize - _from);
+        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(as), _from - prefixSize, as.offset, true);
+        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;
       }
     }
-
     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,
+        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));
+        newVector.suffix = self.suffix.slice(0, suffixSize - (length - _to));
       } else {
-        newVector.root = sliceRight(newVector.root, getDepth(as), _to - prefixSize - 1, newVector.offset);
-
+        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;
       }
     }
-
     newVector.bits = bits;
     return newVector;
   };
@@ -1132,13 +994,9 @@ function slice_1(from, to) {
 /**
  * @tsplus pipeable fncts.Vector sort
  */
-
-
-export function sort(
-/** @tsplus auto */
-O) {
+export function sort( /** @tsplus auto */O) {
   return self => {
-    return sortWith_1(O.compare)(self);
+    return sortWith_1((a, b) => O.compare(b)(a))(self);
   };
 }
 /**
@@ -1152,15 +1010,14 @@ O) {
  *
  * @tsplus pipeable fncts.Vector sortWith
  */
-
 function sortWith_1(compare) {
-  return as => {
+  return self => {
     const arr = [];
     let i = 0;
     forEach_1(elm => arr.push({
       idx: i++,
       elm
-    }))(as);
+    }))(self);
     arr.sort(({
       elm: a,
       idx: i
@@ -1172,11 +1029,9 @@ function sortWith_1(compare) {
       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;
   };
 }
@@ -1190,11 +1045,9 @@ function sortWith_1(compare) {
  *
  * @tsplus pipeable fncts.Vector splitAt
  */
-
-
 function splitAt_1(index) {
-  return as => {
-    return [slice_1(0, index)(as), slice_1(index, as.length)(as)];
+  return self => {
+    return [slice_1(0, index)(self), slice_1(index, self.length)(self)];
   };
 }
 /**
@@ -1205,12 +1058,10 @@ function splitAt_1(index) {
  *
  * @tsplus pipeable fncts.Vector splitWhen
  */
-
-
 export function splitWhen(predicate) {
-  return as => {
-    const idx = findIndex_1(predicate)(as);
-    return idx === -1 ? [as, empty_1()] : splitAt_1(idx)(as);
+  return self => {
+    const idx = findIndex_1(predicate)(self);
+    return idx === -1 ? [self, empty_1()] : splitAt_1(idx)(self);
   };
 }
 /**
@@ -1221,9 +1072,8 @@ export function splitWhen(predicate) {
  *
  * @tsplus getter fncts.Vector tail
  */
-
-export function tail(as) {
-  return slice_1(1, as.length)(as);
+export function tail(self) {
+  return slice_1(1, self.length)(self);
 }
 /**
  * Takes the first `n` elements from a Vector and returns them in a new Vector.
@@ -1231,10 +1081,9 @@ export function tail(as) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector take
  */
-
 export function take(n) {
-  return as => {
-    return slice_1(0, n)(as);
+  return self => {
+    return slice_1(0, n)(self);
   };
 }
 /**
@@ -1246,16 +1095,15 @@ export function take(n) {
  *
  * @tsplus pipeable fncts.Vector takeWhile
  */
-
 export function takeWhile(predicate) {
-  return as => {
+  return self => {
     const {
       index
     } = foldLeftCb(findNotIndexCb, {
       predicate,
       index: 0
-    }, as);
-    return slice_1(0, index)(as);
+    }, self);
+    return slice_1(0, index)(self);
   };
 }
 /**
@@ -1265,10 +1113,9 @@ export function takeWhile(predicate) {
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector takeLast
  */
-
 export function takeLast(n) {
-  return as => {
-    return slice_1(as.length - n, as.length)(as);
+  return self => {
+    return slice_1(self.length - n, self.length)(self);
   };
 }
 /**
@@ -1280,16 +1127,15 @@ export function takeLast(n) {
  *
  * @tsplus pipeable fncts.Vector takeLastWhile
  */
-
 export function takeLastWhile(predicate) {
-  return as => {
+  return self => {
     const {
       index
     } = foldRightCb(findNotIndexCb, {
       predicate,
       index: 0
-    }, as);
-    return slice_1(as.length - index, as.length)(as);
+    }, self);
+    return slice_1(self.length - index, self.length)(self);
   };
 }
 /**
@@ -1298,7 +1144,6 @@ export function takeLastWhile(predicate) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector toArray
  */
-
 export function toArray(self) {
   return foldLeft_1([], arrayPush)(self);
 }
@@ -1308,7 +1153,6 @@ export function toArray(self) {
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector toList
  */
-
 export function toList(self) {
   const buffer = new tsplus_module_6.ListBuffer();
   forEach_1(a => {
@@ -1316,7 +1160,6 @@ export function toList(self) {
   })(self);
   return buffer.toList;
 }
-
 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);
@@ -1326,8 +1169,6 @@ function _traverseWithIndex_1(self) {
 /**
  * @tsplus getter fncts.Vector traverse
  */
-
-
 export function _traverse(self) {
   return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
 }
@@ -1338,23 +1179,20 @@ export const traverse = G => f => self => _traverseWithIndex_1(self)(G)((_, a) =
  * Eq instance to determine when elements are equal
  *
  * @complexity `O(n)`
- * @tsplus getter fncts.Vector uniq
+ * @tsplus pipeable fncts.Vector uniq
  */
-
-export function uniq(as) {
-  return E => dropRepeatsWith_1(E.equals)(as);
+export function uniq(E) {
+  return self => dropRepeatsWith_1((a, b) => E.equals(b)(a))(self);
 }
 /**
  * @tsplus static fncts.VectorOps unfold
  */
-
 export function unfold(b, f) {
   const out = emptyPushable_1();
-  let state = b; // eslint-disable-next-line no-constant-condition
-
+  let state = b;
+  // eslint-disable-next-line no-constant-condition
   while (true) {
     const mt = f(state);
-
     if (tsplus_module_7.isJust(mt)) {
       const [a, b] = mt.value;
       tsplus_module_2.push(a)(out);
@@ -1363,10 +1201,8 @@ export function unfold(b, f) {
       break;
     }
   }
-
   return out;
 }
-
 function findCb(value, state) {
   if (state.predicate(value)) {
     state.result = value;
@@ -1382,14 +1218,12 @@ function findCb(value, state) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector unsafeFind
  */
-
-
 function unsafeFind_1(predicate) {
-  return as => {
+  return self => {
     return foldLeftCb(findCb, {
       predicate,
       result: undefined
-    }, as).result;
+    }, self).result;
   };
 }
 /**
@@ -1399,14 +1233,12 @@ function unsafeFind_1(predicate) {
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector unsafeFindLast
  */
-
-
 function unsafeFindLast_1(predicate) {
-  return as => {
+  return self => {
     return foldRightCb(findCb, {
       predicate,
       result: undefined
-    }, as).result;
+    }, self).result;
   };
 }
 /**
@@ -1417,28 +1249,23 @@ function unsafeFindLast_1(predicate) {
  * @tsplus pipeable fncts.Vector unsafeGet
  * @tsplus pipeable-index fncts.Vector
  */
-
-
 function unsafeGet_1(index) {
-  return l => {
-    if (index < 0 || l.length <= index) {
+  return self => {
+    if (index < 0 || self.length <= index) {
       return undefined;
     }
-
-    const prefixSize = getPrefixSize(l);
-    const suffixSize = getSuffixSize(l);
-
+    const prefixSize = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
     if (index < prefixSize) {
-      return l.prefix[prefixSize - index - 1];
-    } else if (index >= l.length - suffixSize) {
-      return l.suffix[index - (l.length - suffixSize)];
+      return self.prefix[prefixSize - index - 1];
+    } else if (index >= self.length - suffixSize) {
+      return self.suffix[index - (self.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);
+    } = 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);
   };
 }
 /**
@@ -1448,11 +1275,9 @@ function unsafeGet_1(index) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeHead
  */
-
-
-function unsafeHead_1(l) {
-  const prefixSize = getPrefixSize(l);
-  return prefixSize !== 0 ? l.prefix[prefixSize - 1] : l.length !== 0 ? l.suffix[0] : undefined;
+function unsafeHead_1(self) {
+  const prefixSize = getPrefixSize(self);
+  return prefixSize !== 0 ? self.prefix[prefixSize - 1] : self.length !== 0 ? self.suffix[0] : undefined;
 }
 /**
  * Returns the last element of the Vector. If the Vector is empty the
@@ -1461,11 +1286,9 @@ function unsafeHead_1(l) {
  * @complexity O(1)
  * @tsplus getter fncts.Vector unsafeLast
  */
-
-
-function unsafeLast_1(l) {
-  const suffixSize = getSuffixSize(l);
-  return suffixSize !== 0 ? l.suffix[suffixSize - 1] : l.length !== 0 ? l.prefix[0] : undefined;
+function unsafeLast_1(self) {
+  const suffixSize = getSuffixSize(self);
+  return suffixSize !== 0 ? self.suffix[suffixSize - 1] : self.length !== 0 ? self.prefix[0] : undefined;
 }
 /**
  * Returns a Vector that has the entry specified by the index replaced with the given value.
@@ -1475,45 +1298,36 @@ function unsafeLast_1(l) {
  * @complexity O(log(n))
  * @tsplus pipeable fncts.Vector updateAt
  */
-
-
 function updateAt_1(i, a) {
-  return as => {
-    if (i < 0 || as.length <= i) {
-      return as;
+  return self => {
+    if (i < 0 || self.length <= i) {
+      return self;
     }
-
-    const prefixSize = getPrefixSize(as);
-    const suffixSize = getSuffixSize(as);
-    const newVector = mutableClone_1(as);
-
+    const prefixSize = getPrefixSize(self);
+    const suffixSize = getSuffixSize(self);
+    const newVector = mutableClone_1(self);
     if (i < prefixSize) {
       const newPrefix = copyArray(newVector.prefix);
       newPrefix[newPrefix.length - i - 1] = a;
       newVector.prefix = newPrefix;
-    } else if (i >= as.length - suffixSize) {
+    } else if (i >= self.length - suffixSize) {
       const newSuffix = copyArray(newVector.suffix);
-      newSuffix[i - (as.length - suffixSize)] = a;
+      newSuffix[i - (self.length - suffixSize)] = a;
       newVector.suffix = newSuffix;
     } else {
-      newVector.root = updateNode(as.root, getDepth(as), i - prefixSize, as.offset, a);
+      newVector.root = updateNode(self.root, getDepth(self), i - prefixSize, self.offset, a);
     }
-
     return newVector;
   };
 }
 /**
  * @tsplus static fncts.VectorOps __call
  */
-
-
 function vector_1(...elements) {
   const v = emptyPushable_1();
-
   for (const element of elements) {
     tsplus_module_2.push(element)(v);
   }
-
   return v;
 }
 //# sourceMappingURL=api.mjs.map