@fncts/base 0.0.20 → 0.0.22

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

@@ -3,158 +3,160 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
+import { HKT } from "@fncts/typelevel/HKT";
 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";
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector append
- * @tsplus operator fncts.Vector +
+ * @tsplus pipeable fncts.Vector append
+ * @tsplus pipeable-operator fncts.Vector +
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function append_<A>(as: Vector<A>, a: 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 fluent fncts.Vector flatMap
+ * @tsplus pipeable fncts.Vector flatMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function flatMap_<A, B>(ma: Vector<A>, f: (a: A) => Vector<B>): 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 fluent fncts.Vector chunksOf
+ * @tsplus pipeable fncts.Vector chunksOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function chunksOf_<A>(as: Vector<A>, size: number): Vector<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))
- * @tsplus fluent fncts.Vector concat
- * @tsplus operator fncts.Vector + 1
+ * @tsplus pipeable fncts.Vector concat
+ * @tsplus pipeable-operator fncts.Vector + 1
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function concat_<A, B>(self: Vector<A>, that: Vector<B>): Vector<A | B>;
+export declare function concat<B>(that: Vector<B>): <A>(self: Vector<A>) => Vector<A | B>;
 /**
  * Returns `true` if the Vector contains the specified element.
  * Otherwise it returns `false`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector contains
+ * @tsplus pipeable fncts.Vector contains
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function contains_<A>(as: Vector<A>, element: 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 fluent fncts.Vector drop
+ * @tsplus pipeable fncts.Vector drop
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function drop_<A>(as: Vector<A>, n: number): 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 fluent fncts.Vector dropLast
+ * @tsplus pipeable fncts.Vector dropLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropLast_<A>(as: Vector<A>, n: number): 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.
  * @complexity `O(n)`
- * @tsplus fluent fncts.Vector dropRepeatsWith
+ * @tsplus pipeable fncts.Vector dropRepeatsWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropRepeatsWith_<A>(as: Vector<A>, predicate: (a: A, b: A) => boolean): 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`.
  * @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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function dropWhile_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A>;
+export declare function dropWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
- * @tsplus getter fncts.Vector elem
+ * @tsplus pipeable fncts.Vector elem
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function elem_<A>(self: Vector<A>): (E: Eq<A>) => (a: A) => boolean;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Vector<A>) => boolean;
 /**
  * Returns true if the two Vectors are equivalent.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector equals
+ * @tsplus pipeable fncts.Vector equals
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function equals_<A>(self: Vector<A>, that: Vector<A>): boolean;
+export declare function equals<A>(that: Vector<A>): (self: Vector<A>) => boolean;
 /**
  * Returns `true` if and only if the predicate function returns `true`
  * for all elements in the given Vector.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector every
+ * @tsplus pipeable fncts.Vector every
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function every_<A, B extends A>(as: Vector<A>, refinement: Refinement<A, B>): as is Vector<B>;
-export declare function every_<A>(as: Vector<A>, predicate: Predicate<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 fluent fncts.Vector exists
+ * @tsplus pipeable fncts.Vector some
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function exists_<A>(as: Vector<A>, predicate: Predicate<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`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector find
+ * @tsplus pipeable fncts.Vector find
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function find_<A>(as: Vector<A>, predicate: Predicate<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
  * `-1`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findIndex
+ * @tsplus pipeable fncts.Vector findIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findIndex_<A>(as: Vector<A>, predicate: Predicate<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`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLast
+ * @tsplus pipeable fncts.Vector findLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findLast_<A>(as: Vector<A>, predicate: Predicate<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
  * `-1`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector findLastIndex
+ * @tsplus pipeable fncts.Vector findLastIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function findLastIndex_<A>(as: Vector<A>, predicate: Predicate<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.
@@ -162,7 +164,7 @@ export declare function findLastIndex_<A>(as: Vector<A>, predicate: Predicate<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)
@@ -172,50 +174,49 @@ export declare function flatten<A>(mma: Vector<Vector<A>>): Vector<A>;
 export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): Vector<A>;
 /**
  * Folds a function over a Vector. Left-associative.
- * @tsplus fluent fncts.Vector foldLeft
+ * @tsplus pipeable fncts.Vector foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeft_<A, B>(fa: Vector<A>, initial: B, f: (acc: B, a: A) => B): B;
+export declare function foldLeft<A, B>(initial: B, f: (acc: B, a: A) => B): (self: Vector<A>) => B;
 /**
- * @tsplus fluent fncts.Vector foldLeftWithIndex
+ * @tsplus pipeable fncts.Vector foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeftWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
- * @tsplus fluent fncts.Vector foldLeftWhile
+ * @tsplus pipeable fncts.Vector foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldLeftWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B): 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 fluent fncts.Vector foldRightWhile
+ * @tsplus pipeable fncts.Vector foldRightWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRightWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): 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 fluent fncts.Vector foldMap
+ * @tsplus pipeable fncts.Vector foldMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldMap_<A, M>(self: Vector<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: Vector<A>) => M;
 /**
- * @tsplus fluent fncts.Vector foldMapWithIndex
+ * @tsplus pipeable fncts.Vector foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldMapWithIndex_<A, M>(self: Vector<A>, f: (i: number, a: A) => M, 
-/** @tsplus auto */ M: Monoid<M>): M;
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: Vector<A>) => M;
 /**
  * Folds a function over a Vector. Right-associative.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector foldRight
+ * @tsplus pipeable fncts.Vector foldRight
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRight_<A, B>(fa: Vector<A>, initial: B, f: (value: A, acc: B) => B): 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 fluent fncts.Vector foldRightWithIndex
+ * @tsplus pipeable fncts.Vector foldRightWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRightWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: number, a: A, b: B) => B): 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`.
@@ -225,23 +226,23 @@ export declare function foldRightWithIndex_<A, B>(fa: Vector<A>, b: B, f: (i: nu
  * constructs a new Vector `forEach` merely returns `undefined`. This
  * makes `forEach` faster when the new Vector is unneeded.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector forEach
+ * @tsplus pipeable fncts.Vector forEach
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function forEach_<A>(as: Vector<A>, f: (a: A) => void): void;
+export declare function forEach<A>(f: (a: A) => void): (self: Vector<A>) => void;
 /**
- * @tsplus fluent fncts.Vector forEachWithIndex
+ * @tsplus pipeable fncts.Vector forEachWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function forEachWithIndex_<A>(as: Vector<A>, f: (i: number, a: A) => void): 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.
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector get
+ * @tsplus pipeable fncts.Vector get
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function get_<A>(self: Vector<A>, index: number): Maybe<A>;
+export declare function get(index: number): <A>(self: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => import("../../../data/Maybe").Maybe<A>;
 /**
  * Returns a Vector of Vectors where each subvector's elements are pairwise
  * equal based on the given comparison function.
@@ -249,10 +250,10 @@ export declare function get_<A>(self: Vector<A>, index: number): Maybe<A>;
  * Note that only adjacent elements are compared for equality. If all
  * equal elements should be grouped together the Vector should be sorted
  * before grouping.
- * @tsplus fluent fncts.Vector groupWith
+ * @tsplus pipeable fncts.Vector groupWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function groupWith_<A>(as: Vector<A>, f: (a: A, b: A) => boolean): 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)
@@ -264,61 +265,61 @@ export declare function head<A>(self: Vector<A>): Maybe<NonNullable<A>>;
  * Returns the index of the _first_ element in the Vector that is equal
  * 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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function indexOf_<A>(as: Vector<A>, element: 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 fluent fncts.Vector insertAt
+ * @tsplus pipeable fncts.Vector insertAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function insertAt_<A>(as: Vector<A>, index: number, element: 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 fluent fncts.Vector insertAllAt
+ * @tsplus pipeable fncts.Vector insertAllAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function insertAllAt_<A>(as: Vector<A>, index: number, elements: 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 fluent fncts.Vector intersperse
+ * @tsplus pipeable fncts.Vector intersperse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function intersperse_<A>(as: Vector<A>, separator: 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 fluent fncts.Vector join
+ * @tsplus pipeable fncts.Vector join
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function join_(as: Vector<string>, separator: 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.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector lastIndexOf
+ * @tsplus pipeable fncts.Vector lastIndexOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function lastIndexOf_<A>(as: Vector<A>, element: 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.
@@ -328,31 +329,31 @@ export declare function lastIndexOf_<A>(as: Vector<A>, element: A): number;
  */
 export declare function makeBy<A>(n: number, f: (index: number) => A): Vector<A>;
 /**
- * @tsplus fluent fncts.Vector mapAccum
+ * @tsplus pipeable fncts.Vector mapAccum
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function mapAccum_<A, S, B>(fa: Vector<A>, s: S, f: (s: S, a: A) => readonly [B, S]): 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.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector map
+ * @tsplus pipeable fncts.Vector map
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function map_<A, B>(fa: Vector<A>, f: (a: A) => B): 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.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector mapWithIndex
+ * @tsplus pipeable fncts.Vector mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function mapWithIndex_<A, B>(fa: Vector<A>, f: (i: number, a: A) => B): 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.
@@ -360,18 +361,18 @@ export declare function mutableClone<A>(as: Vector<A>): MutableVector<A>;
  * If the index is out of bounds the given Vector is
  * returned unchanged.
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector modifyAt
+ * @tsplus pipeable fncts.Vector modifyAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function modifyAt_<A>(as: Vector<A>, i: number, f: (a: A) => 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.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector none
+ * @tsplus pipeable fncts.Vector none
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function none_<A>(as: Vector<A>, predicate: Predicate<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)
@@ -386,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 fluent fncts.Vector prepend
+ * @tsplus pipeable fncts.Vector prepend
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function prepend_<A>(as: Vector<A>, a: 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)
@@ -411,10 +412,10 @@ export declare function range(start: number, end: number): Vector<number>;
  * new Vector with the given amount of elements removed from the specified
  * index.
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector remove
+ * @tsplus pipeable fncts.Vector remove
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function remove_<A>(as: Vector<A>, from: number, amount: number): 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.
@@ -431,10 +432,10 @@ export declare 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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function scanLeft_<A, B>(as: Vector<A>, initial: B, f: (acc: B, value: A) => B): 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)
@@ -447,15 +448,15 @@ export declare function single<A>(a: A): Vector<A>;
  * end. Both the indices can be negative in which case they will count
  * from the right end of the Vector.
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector slice
+ * @tsplus pipeable fncts.Vector slice
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function slice_<A>(as: Vector<A>, from: number, to: number): 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 fluent fncts.Vector sort
+ * @tsplus pipeable fncts.Vector sort
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector<A>;
+export declare function sort<A>(/** @tsplus auto */ O: Ord<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Sort the given Vector by comparing values using the given function.
  * The function receieves two values and should return `-1` if the
@@ -463,28 +464,28 @@ export declare function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>)
  * equal and `1` if the first values is strictly smaller than the
  * second.
  * @complexity O(n * log(n))
- * @tsplus fluent fncts.Vector sortWith
+ * @tsplus pipeable fncts.Vector sortWith
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function sortWith_<A>(as: Vector<A>, compare: (a: A, b: A) => Ordering): 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
  * element at the given index. The right side contains the element at the
  * index and all elements after it.
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector splitAt
+ * @tsplus pipeable fncts.Vector splitAt
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function splitAt_<A>(as: Vector<A>, index: number): [Vector<A>, 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`.
  * @complexity `O(n)`
- * @tsplus fluent fncts.Vector splitWhen
+ * @tsplus pipeable fncts.Vector splitWhen
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function splitWhen_<A>(as: Vector<A>, predicate: Predicate<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.
@@ -492,40 +493,40 @@ export declare function splitWhen_<A>(as: Vector<A>, predicate: Predicate<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 fluent fncts.Vector take
+ * @tsplus pipeable fncts.Vector take
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function take_<A>(as: Vector<A>, n: number): 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`.
  * @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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeWhile_<A>(as: Vector<A>, predicate: Predicate<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.
  * @complexity `O(log(n))`
- * @tsplus fluent fncts.Vector takeLast
+ * @tsplus pipeable fncts.Vector takeLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeLast_<A>(as: Vector<A>, n: number): 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`.
  * @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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function takeLastWhile_<A>(as: Vector<A>, predicate: Predicate<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)`
@@ -544,20 +545,22 @@ export declare function toList<A>(self: Vector<A>): List<A>;
  * @tsplus getter fncts.Vector traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: import("@fncts/base/typeclass").Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/Vector/definition").Vector<B>>;
+export declare 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>>;
 /**
  * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
+export declare function _traverse<A>(self: Vector<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/Vector/definition").Vector<B>>;
+export declare const traverseWithIndex: P.TraversableWithIndex<VectorF>["traverseWithIndex"];
 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"
@@ -567,26 +570,27 @@ export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>):
  * Returns the _first_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFind
+ * @tsplus pipeable fncts.Vector unsafeFind
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeFind_<A>(as: Vector<A>, predicate: Predicate<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`.
  * @complexity O(n)
- * @tsplus fluent fncts.Vector unsafeFindLast
+ * @tsplus pipeable fncts.Vector unsafeFindLast
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeFindLast_<A>(as: Vector<A>, predicate: Predicate<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.
  * @complexity O(log(n))
- * @tsplus fluent fncts.Vector unsafeGet
+ * @tsplus pipeable fncts.Vector unsafeGet
+ * @tsplus pipeable-index fncts.Vector
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function unsafeGet_<A>(l: Vector<A>, index: number): 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.
@@ -594,7 +598,7 @@ export declare function unsafeGet_<A>(l: Vector<A>, index: number): A | undefine
  * @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`.
@@ -602,16 +606,16 @@ 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.
  *
  * 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
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function updateAt_<A>(as: Vector<A>, i: number, a: 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"