@fncts/base 0.0.21 → 0.0.23

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

@@ -14,20 +14,20 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus pipeable-operator fncts.Vector +
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function append<A>(a: A): (as: Vector<A>) => Vector<A>;
+export declare function append<A>(a: A): (self: Vector<A>) => Vector<A>;
 /**
  * Maps a function over a Vector and concatenates all the resulting
  * Vectors together.
  * @tsplus pipeable fncts.Vector flatMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function flatMap<A, B>(f: (a: A) => Vector<B>): (ma: Vector<A>) => Vector<B>;
+export declare function flatMap<A, B>(f: (a: A) => Vector<B>): (self: Vector<A>) => Vector<B>;
 /**
  * Splits the Vector into chunks of the given size.
  * @tsplus pipeable fncts.Vector chunksOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function chunksOf(size: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<import("@fncts/base/collection/immutable/Vector/definition").Vector<A>>;
+export declare function chunksOf(size: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<import("@fncts/base/collection/immutable/Vector/definition").Vector<A>>;
 /**
  * Concatenates two Vectors.
  * @complexity O(log(n))
@@ -43,28 +43,28 @@ export declare function concat<B>(that: Vector<B>): <A>(self: Vector<A>) => Vect
  * @tsplus pipeable fncts.Vector contains
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function contains<A>(element: A): (as: Vector<A>) => boolean;
+export declare function contains<A>(element: A): (self: Vector<A>) => boolean;
 /**
  * Returns a new Vector without the first `n` elements.
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector drop
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function drop(n: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function drop(n: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * Returns a new Vector without the last `n` elements.
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector dropLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropLast(n: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function dropLast(n: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * Returns a new Vector without repeated elements.
  * @complexity `O(n)`
  * @tsplus getter fncts.Vector dropRepeats
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropRepeats<A>(as: Vector<A>): Vector<A>;
+export declare function dropRepeats<A>(self: Vector<A>): Vector<A>;
 /**
  * Returns a new Vector without repeated elements by using the given
  * function to determine when elements are equal.
@@ -72,7 +72,7 @@ export declare function dropRepeats<A>(as: Vector<A>): Vector<A>;
  * @tsplus pipeable fncts.Vector dropRepeatsWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropRepeatsWith<A>(predicate: (a: A, b: A) => boolean): (as: Vector<A>) => Vector<A>;
+export declare function dropRepeatsWith<A>(predicate: (a: A, b: A) => boolean): (self: Vector<A>) => Vector<A>;
 /**
  * Removes the first elements in the Vector for which the predicate returns
  * `true`.
@@ -81,7 +81,7 @@ satisfying the predicate.
  * @tsplus pipeable fncts.Vector dropWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropWhile<A>(predicate: Predicate<A>): (as: Vector<A>) => Vector<A>;
+export declare function dropWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * @tsplus pipeable fncts.Vector elem
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -101,28 +101,28 @@ export declare function equals<A>(that: Vector<A>): (self: Vector<A>) => boolean
  * @tsplus pipeable fncts.Vector every
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function every<A, B extends A>(refinement: Refinement<A, B>): (as: Vector<A>) => as is Vector<B>;
-export declare function every<A>(predicate: Predicate<A>): (as: Vector<A>) => boolean;
+export declare function every<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => self is Vector<B>;
+export declare function every<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * Creates an empty Vector.
  * @complexity O(1)
  * @tsplus static fncts.VectorOps empty
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function empty<A = any>(): Vector<A>;
+export declare function empty<A = never>(): Vector<A>;
 /**
  * @tsplus static fncts.VectorOps emptyPushable
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function emptyPushable<A>(): MutableVector<A>;
+export declare function emptyPushable<A = never>(): MutableVector<A>;
 /**
  * Returns true if and only if there exists an element in the Vector for
  * which the predicate returns true.
  * @complexity O(n)
- * @tsplus pipeable fncts.Vector exists
+ * @tsplus pipeable fncts.Vector some
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function exists<A>(predicate: Predicate<A>): (as: Vector<A>) => boolean;
+export declare function some<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * Returns the _first_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
@@ -130,7 +130,7 @@ export declare function exists<A>(predicate: Predicate<A>): (as: Vector<A>) => b
  * @tsplus pipeable fncts.Vector find
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function find<A>(predicate: Predicate<A>): (as: Vector<A>) => Maybe<A>;
+export declare function find<A>(predicate: Predicate<A>): (self: Vector<A>) => Maybe<A>;
 /**
  * Returns the index of the `first` element for which the predicate
  * returns true. If no such element is found the function returns
@@ -139,7 +139,7 @@ export declare function find<A>(predicate: Predicate<A>): (as: Vector<A>) => May
  * @tsplus pipeable fncts.Vector findIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findIndex<A>(predicate: Predicate<A>): (as: Vector<A>) => number;
+export declare function findIndex<A>(predicate: Predicate<A>): (self: Vector<A>) => number;
 /**
  * Returns the _last_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
@@ -147,7 +147,7 @@ export declare function findIndex<A>(predicate: Predicate<A>): (as: Vector<A>) =
  * @tsplus pipeable fncts.Vector findLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findLast<A>(predicate: Predicate<A>): (as: Vector<A>) => Maybe<A>;
+export declare function findLast<A>(predicate: Predicate<A>): (self: Vector<A>) => Maybe<A>;
 /**
  * Returns the index of the `last` element for which the predicate
  * returns true. If no such element is found the function returns
@@ -156,7 +156,7 @@ export declare function findLast<A>(predicate: Predicate<A>): (as: Vector<A>) =>
  * @tsplus pipeable fncts.Vector findLastIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findLastIndex<A>(predicate: Predicate<A>): (as: Vector<A>) => number;
+export declare function findLastIndex<A>(predicate: Predicate<A>): (self: Vector<A>) => number;
 /**
  * Flattens a Vector of Vectors into a Vector. Note that this function does
  * not flatten recursively. It removes one level of nesting only.
@@ -164,7 +164,7 @@ export declare function findLastIndex<A>(predicate: Predicate<A>): (as: Vector<A
  * @tsplus getter fncts.Vector flatten
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function flatten<A>(mma: Vector<Vector<A>>): Vector<A>;
+export declare function flatten<A>(self: Vector<Vector<A>>): Vector<A>;
 /**
  * Converts an array, an array-like, or an iterable into a Vector.
  * @complexity O(n)
@@ -177,22 +177,22 @@ export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): Vec
  * @tsplus pipeable fncts.Vector foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeft<A, B>(initial: B, f: (acc: B, a: A) => B): (fa: Vector<A>) => B;
+export declare function foldLeft<A, B>(initial: B, f: (acc: B, a: A) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (fa: Vector<A>) => B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeftWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B): (fa: Vector<A>) => B;
+export declare function foldLeftWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldRightWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRightWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): (fa: Vector<A>) => B;
+export declare function foldRightWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -209,14 +209,14 @@ export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @t
  * @tsplus pipeable fncts.Vector foldRight
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRight<A, B>(initial: B, f: (value: A, acc: B) => B): (fa: Vector<A>) => B;
+export declare function foldRight<A, B>(initial: B, f: (value: A, acc: B) => B): (self: Vector<A>) => B;
 /**
  * Folds a function over a Vector. Right-associative.
  * @complexity O(n)
  * @tsplus pipeable fncts.Vector foldRightWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (fa: Vector<A>) => B;
+export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (self: Vector<A>) => B;
 /**
  * Invokes a given callback for each element in the Vector from left to
  * right. Returns `undefined`.
@@ -229,12 +229,12 @@ export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B
  * @tsplus pipeable fncts.Vector forEach
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function forEach<A>(f: (a: A) => void): (as: Vector<A>) => void;
+export declare function forEach<A>(f: (a: A) => void): (self: Vector<A>) => void;
 /**
  * @tsplus pipeable fncts.Vector forEachWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function forEachWithIndex<A>(f: (i: number, a: A) => void): (as: Vector<A>) => void;
+export declare function forEachWithIndex<A>(f: (i: number, a: A) => void): (self: Vector<A>) => void;
 /**
  * Gets the nth element of the Vector. If `n` is out of bounds
  * `undefined` is returned.
@@ -253,7 +253,7 @@ export declare function get(index: number): <A>(self: import("@fncts/base/collec
  * @tsplus pipeable fncts.Vector groupWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function groupWith<A>(f: (a: A, b: A) => boolean): (as: Vector<A>) => Vector<Vector<A>>;
+export declare function groupWith<A>(f: (a: A, b: A) => boolean): (self: Vector<A>) => Vector<Vector<A>>;
 /**
  * Returns the first element of the Vector.
  * @complexity O(1)
@@ -268,50 +268,50 @@ export declare function head<A>(self: Vector<A>): Maybe<NonNullable<A>>;
  * @tsplus pipeable fncts.Vector indexOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function indexOf<A>(element: A): (as: Vector<A>) => number;
+export declare function indexOf<A>(element: A): (self: Vector<A>) => number;
 /**
  * Inserts the given element at the given index in the Vector.
  * @complexity O(log(n))
  * @tsplus pipeable fncts.Vector insertAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function insertAt<A>(index: number, element: A): (as: Vector<A>) => Vector<A>;
+export declare function insertAt<A>(index: number, element: A): (self: Vector<A>) => Vector<A>;
 /**
  * Inserts the given Vector of elements at the given index in the Vector.
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector insertAllAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function insertAllAt<A>(index: number, elements: Vector<A>): (as: Vector<A>) => Vector<A>;
+export declare function insertAllAt<A>(index: number, elements: Vector<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Inserts a separator between each element in a Vector.
  * @tsplus pipeable fncts.Vector intersperse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function intersperse<A>(separator: A): (as: Vector<A>) => Vector<A>;
+export declare function intersperse<A>(separator: A): (self: Vector<A>) => Vector<A>;
 /**
  * @tsplus fluent fncts.Vector isEmpty
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function isEmpty<A>(l: Vector<A>): boolean;
+export declare function isEmpty<A>(self: Vector<A>): boolean;
 /**
  * @tsplus fluent fncts.Vector isNonEmpty
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function isNonEmpty<A>(l: Vector<A>): boolean;
+export declare function isNonEmpty<A>(self: Vector<A>): boolean;
 /**
  * Concatenates the strings in the Vector separated by a specified separator.
  * @tsplus pipeable fncts.Vector join
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function join(separator: string): (as: Vector<string>) => string;
+export declare function join(separator: string): (self: Vector<string>) => string;
 /**
  * Returns the last element of the Vector.
  * @complexity O(1)
  * @tsplus getter fncts.Vector last
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function last<A>(l: Vector<A>): Maybe<NonNullable<A>>;
+export declare function last<A>(self: Vector<A>): Maybe<NonNullable<A>>;
 /**
  * Returns the index of the _last_ element in the Vector that is equal
  * to the given element. If no such element is found `-1` is returned.
@@ -319,7 +319,7 @@ export declare function last<A>(l: Vector<A>): Maybe<NonNullable<A>>;
  * @tsplus pipeable fncts.Vector lastIndexOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function lastIndexOf<A>(element: A): (as: Vector<A>) => number;
+export declare function lastIndexOf<A>(element: A): (self: Vector<A>) => number;
 /**
  * Generates a new Vector by calling a function with the current index
  * `n` times.
@@ -332,7 +332,7 @@ export declare function makeBy<A>(n: number, f: (index: number) => A): Vector<A>
  * @tsplus pipeable fncts.Vector mapAccum
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (fa: Vector<A>) => readonly [Vector<B>, S];
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (self: Vector<A>) => readonly [Vector<B>, S];
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
@@ -340,7 +340,7 @@ export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B,
  * @tsplus pipeable fncts.Vector map
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function map<A, B>(f: (a: A) => B): (fa: Vector<A>) => Vector<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Vector<A>) => Vector<B>;
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
@@ -348,12 +348,12 @@ export declare function map<A, B>(f: (a: A) => B): (fa: Vector<A>) => Vector<B>;
  * @tsplus pipeable fncts.Vector mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (fa: Vector<A>) => Vector<B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: Vector<A>) => Vector<B>;
 /**
  * @tsplus getter fncts.Vector mutableClone
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function mutableClone<A>(as: Vector<A>): MutableVector<A>;
+export declare function mutableClone<A>(self: Vector<A>): MutableVector<A>;
 /**
  * Returns a Vector that has the entry specified by the index replaced with
  * the value returned by applying the function to the value.
@@ -364,7 +364,7 @@ export declare function mutableClone<A>(as: Vector<A>): MutableVector<A>;
  * @tsplus pipeable fncts.Vector modifyAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function modifyAt<A>(i: number, f: (a: A) => A): (as: Vector<A>) => Vector<A>;
+export declare function modifyAt<A>(i: number, f: (a: A) => A): (self: Vector<A>) => Vector<A>;
 /**
  * Returns `true` if and only if the predicate function returns
  * `false` for every element in the given Vector.
@@ -372,7 +372,7 @@ export declare function modifyAt<A>(i: number, f: (a: A) => A): (as: Vector<A>)
  * @tsplus pipeable fncts.Vector none
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function none<A>(predicate: Predicate<A>): (as: Vector<A>) => boolean;
+export declare function none<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * Takes two arguments and returns a Vector that contains them.
  * @complexity O(1)
@@ -387,19 +387,19 @@ export declare function pair<A>(first: A, second: A): Vector<A>;
  * @tsplus getter fncts.Vector pop
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function pop<A>(as: Vector<A>): Vector<A>;
+export declare function pop<A>(self: Vector<A>): Vector<A>;
 /**
  * Prepends an element to the front of a Vector and returns the new Vector.
  * @complexity O(1)
  * @tsplus pipeable fncts.Vector prepend
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function prepend<A>(a: A): (as: Vector<A>) => Vector<A>;
+export declare function prepend<A>(a: A): (self: Vector<A>) => Vector<A>;
 /**
  * @tsplus operator fncts.Vector +
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function prependOperator<A>(a: A, as: Vector<A>): Vector<A>;
+export declare function prependOperator<A>(a: A, self: Vector<A>): Vector<A>;
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
  * @complexity O(n)
@@ -415,7 +415,7 @@ export declare function range(start: number, end: number): Vector<number>;
  * @tsplus pipeable fncts.Vector remove
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function remove(from: number, amount: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function remove(from: number, amount: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * Returns a Vector of a given length that contains the specified value
  * in all positions.
@@ -435,7 +435,7 @@ export declare function reverse<A>(self: Vector<A>): Vector<A>;
  * @tsplus pipeable fncts.Vector scanLeft
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function scanLeft<A, B>(initial: B, f: (acc: B, value: A) => B): (as: Vector<A>) => Vector<B>;
+export declare function scanLeft<A, B>(initial: B, f: (acc: B, value: A) => B): (self: Vector<A>) => Vector<B>;
 /**
  * Takes a single arguments and returns a singleton Vector that contains it.
  * @complexity O(1)
@@ -451,7 +451,7 @@ export declare function single<A>(a: A): Vector<A>;
  * @tsplus pipeable fncts.Vector slice
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function slice(from: number, to: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function slice(from: number, to: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * @tsplus pipeable fncts.Vector sort
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -467,7 +467,7 @@ export declare function sort<A>(/** @tsplus auto */ O: Ord<A>): (self: Vector<A>
  * @tsplus pipeable fncts.Vector sortWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function sortWith<A>(compare: (a: A, b: A) => Ordering): (as: Vector<A>) => Vector<A>;
+export declare function sortWith<A>(compare: (a: A, b: A) => Ordering): (self: Vector<A>) => Vector<A>;
 /**
  * Splits a Vector at the given index and return the two sides in a pair.
  * The left side will contain all elements before but not including the
@@ -477,7 +477,7 @@ export declare function sortWith<A>(compare: (a: A, b: A) => Ordering): (as: Vec
  * @tsplus pipeable fncts.Vector splitAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function splitAt(index: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => [import("@fncts/base/collection/immutable/Vector/definition").Vector<A>, import("@fncts/base/collection/immutable/Vector/definition").Vector<A>];
+export declare function splitAt(index: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => [import("@fncts/base/collection/immutable/Vector/definition").Vector<A>, import("@fncts/base/collection/immutable/Vector/definition").Vector<A>];
 /**
  * Splits a Vector at the first element in the Vector for which the given
  * predicate returns `true`.
@@ -485,7 +485,7 @@ export declare function splitAt(index: number): <A>(as: import("@fncts/base/coll
  * @tsplus pipeable fncts.Vector splitWhen
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function splitWhen<A>(predicate: Predicate<A>): (as: Vector<A>) => [Vector<A>, Vector<A>];
+export declare function splitWhen<A>(predicate: Predicate<A>): (self: Vector<A>) => [Vector<A>, Vector<A>];
 /**
  * Returns a new Vector with the first element removed. If the Vector is
  * empty the empty Vector is returned.
@@ -493,14 +493,14 @@ export declare function splitWhen<A>(predicate: Predicate<A>): (as: Vector<A>) =
  * @tsplus getter fncts.Vector tail
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function tail<A>(as: Vector<A>): Vector<A>;
+export declare function tail<A>(self: Vector<A>): Vector<A>;
 /**
  * Takes the first `n` elements from a Vector and returns them in a new Vector.
  * @complexity `O(log(n))`
  * @tsplus pipeable fncts.Vector take
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function take(n: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function take(n: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * Takes the first elements in the Vector for which the predicate returns
  * `true`.
@@ -509,7 +509,7 @@ the predicate.
  * @tsplus pipeable fncts.Vector takeWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeWhile<A>(predicate: Predicate<A>): (as: Vector<A>) => Vector<A>;
+export declare function takeWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Takes the last `n` elements from a Vector and returns them in a new
  * Vector.
@@ -517,7 +517,7 @@ export declare function takeWhile<A>(predicate: Predicate<A>): (as: Vector<A>) =
  * @tsplus pipeable fncts.Vector takeLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeLast(n: number): <A>(as: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function takeLast(n: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * Takes the last elements in the Vector for which the predicate returns
  * `true`.
@@ -526,7 +526,7 @@ satisfying the predicate.
  * @tsplus pipeable fncts.Vector takeLastWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeLastWhile<A>(predicate: Predicate<A>): (as: Vector<A>) => Vector<A>;
+export declare function takeLastWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Converts a Vector into an array.
  * @complexity `O(n)`
@@ -557,10 +557,10 @@ export declare const traverse: Traversable<VectorF>["traverse"];
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
  * @complexity `O(n)`
- * @tsplus getter fncts.Vector uniq
+ * @tsplus pipeable fncts.Vector uniq
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function uniq<A>(as: Vector<A>): (E: Eq<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
+export declare function uniq<A>(E: Eq<A>): (self: Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
 /**
  * @tsplus static fncts.VectorOps unfold
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -573,7 +573,7 @@ export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>):
  * @tsplus pipeable fncts.Vector unsafeFind
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeFind<A>(predicate: Predicate<A>): (as: Vector<A>) => A | undefined;
+export declare function unsafeFind<A>(predicate: Predicate<A>): (self: Vector<A>) => A | undefined;
 /**
  * Returns the _last_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
@@ -581,7 +581,7 @@ export declare function unsafeFind<A>(predicate: Predicate<A>): (as: Vector<A>)
  * @tsplus pipeable fncts.Vector unsafeFindLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeFindLast<A>(predicate: Predicate<A>): (as: Vector<A>) => A | undefined;
+export declare function unsafeFindLast<A>(predicate: Predicate<A>): (self: Vector<A>) => A | undefined;
 /**
  * Gets the nth element of the Vector. If `n` is out of bounds
  * `undefined` is returned.
@@ -590,7 +590,7 @@ export declare function unsafeFindLast<A>(predicate: Predicate<A>): (as: Vector<
  * @tsplus pipeable-index fncts.Vector
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeGet(index: number): <A>(l: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => A | undefined;
+export declare function unsafeGet(index: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => A | undefined;
 /**
  * Returns the first element of the Vector. If the Vector is empty the
  * function returns undefined.
@@ -598,7 +598,7 @@ export declare function unsafeGet(index: number): <A>(l: import("@fncts/base/col
  * @tsplus getter fncts.Vector unsafeHead
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeHead<A>(l: Vector<A>): A | undefined;
+export declare function unsafeHead<A>(self: Vector<A>): A | undefined;
 /**
  * Returns the last element of the Vector. If the Vector is empty the
  * function returns `undefined`.
@@ -606,7 +606,7 @@ export declare function unsafeHead<A>(l: Vector<A>): A | undefined;
  * @tsplus getter fncts.Vector unsafeLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeLast<A>(l: Vector<A>): A | undefined;
+export declare function unsafeLast<A>(self: Vector<A>): A | undefined;
 /**
  * Returns a Vector that has the entry specified by the index replaced with the given value.
  *
@@ -615,7 +615,7 @@ export declare function unsafeLast<A>(l: Vector<A>): A | undefined;
  * @tsplus pipeable fncts.Vector updateAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function updateAt<A>(i: number, a: A): (as: Vector<A>) => Vector<A>;
+export declare function updateAt<A>(i: number, a: A): (self: Vector<A>) => Vector<A>;
 /**
  * @tsplus static fncts.VectorOps __call
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"

package/collection/immutable/Vector/definition.d.ts

@@ -1,7 +1,9 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
+export declare const VectorVariance: unique symbol;
+export type VectorVariance = typeof VectorVariance;
 export declare const VectorTypeId: unique symbol;
 export type VectorTypeId = typeof VectorTypeId;
 export interface VectorF extends HKT {
@@ -29,8 +31,10 @@ export declare class Vector<A> implements Iterable<A> {
     readonly root: Node | undefined;
     /** @private */
     readonly suffix: A[];
-    readonly _typeId: VectorTypeId;
-    readonly _A: () => A;
+    readonly [VectorTypeId]: VectorTypeId;
+    [VectorVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(
     /** @private */
     bits: number, 
@@ -50,8 +54,10 @@ export declare class Vector<A> implements Iterable<A> {
  * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
-    readonly _typeId: VectorTypeId;
-    readonly _A: () => A;
+    readonly [VectorTypeId]: VectorTypeId;
+    readonly [VectorVariance]: {
+        readonly _A: (_: never) => A;
+    };
     bits: number;
     offset: number;
     length: number;

package/collection/immutable.d.ts

@@ -1,4 +1,5 @@
 export type {} from "./immutable/Conc.js";
+export type {} from "./immutable/Dictionary.js";
 export type {} from "./immutable/HashMap.js";
 export type {} from "./immutable/HashSet.js";
 export type {} from "./immutable/ImmutableArray.js";

package/collection/mutable/HashMap.d.ts

@@ -1,6 +1,6 @@
 import { Maybe, Just, Nothing } from "@fncts/base/data/Maybe/definition";
 import { unsafeCoerce } from "@fncts/base/data/function/api";
-import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { HashEq } from "@fncts/base/data/HashEq";
 /**
  * @tsplus type fncts.MutableHashMap
  * @tsplus companion fncts.MutableHashMapOps
@@ -40,7 +40,7 @@ declare class Node<K, V> {
     value: V;
     next: Node<K, V> | undefined;
     constructor(key: K, hash: number, value: V, next: Node<K, V> | undefined);
-    findNode(k: K, h: number, equals: (x: K, y: K) => boolean): Node<K, V> | undefined;
+    findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K, V> | undefined;
     forEach<U>(f: (k: K, v: V) => U): void;
 }
 export declare class HashMapIterator<K, V, A> implements Iterator<A> {

package/collection/mutable/HashSet.d.ts

@@ -1,5 +1,5 @@
 import { unsafeCoerce } from "@fncts/base/data/function/api";
-import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { HashEq } from "@fncts/base/data/HashEq";
 /**
  * @tsplus type fncts.MutableHashSet
  * @tsplus companion fncts.MutableHashSetOps
@@ -32,7 +32,7 @@ declare class Node<K> {
     hash: number;
     next: Node<K> | undefined;
     constructor(key: K, hash: number, next: Node<K> | undefined);
-    findNode(k: K, h: number, equals: (x: K, y: K) => boolean): Node<K> | undefined;
+    findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K> | undefined;
     forEach<U>(f: (k: K) => U): void;
 }
 export declare class HashSetIterator<V, A> implements Iterator<A> {