@fncts/base 0.0.1

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

@@ -0,0 +1,596 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+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 type { MutableVector } from "@fncts/base/collection/immutable/Vector/definition";
+import type { Eq, Monoid, Ord, Ordering } 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function append_<A>(as: Vector<A>, a: A): Vector<A>;
+/**
+ * Maps a function over a Vector and concatenates all the resulting
+ * Vectors together.
+ * @tsplus fluent 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>;
+/**
+ * Splits the Vector into chunks of the given size.
+ * @tsplus fluent fncts.Vector chunksOf
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function chunksOf_<A>(as: Vector<A>, size: number): Vector<Vector<A>>;
+/**
+ * Concatenates two Vectors.
+ * @complexity O(log(n))
+ * @tsplus fluent fncts.Vector concat
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function concat_<A, B>(self: Vector<A>, that: Vector<B>): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function contains_<A>(as: Vector<A>, element: A): boolean;
+/**
+ * Returns a new Vector without the first `n` elements.
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector drop
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function drop_<A>(as: Vector<A>, n: number): Vector<A>;
+/**
+ * Returns a new Vector without the last `n` elements.
+ * @complexity `O(log(n))`
+ * @tsplus fluent fncts.Vector dropLast
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function dropLast_<A>(as: Vector<A>, n: number): 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>;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function dropRepeatsWith_<A>(as: Vector<A>, predicate: (a: A, b: A) => boolean): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function dropWhile_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A>;
+/**
+ * @tsplus getter 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;
+/**
+ * Returns true if the two Vectors are equivalent.
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector equals
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function equals_<A>(self: Vector<A>, that: 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 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;
+/**
+ * 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>;
+/**
+ * @tsplus static fncts.VectorOps emptyPushable
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function emptyPushable<A>(): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function exists_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function find_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function findIndex_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function findLast_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function findLastIndex_<A>(as: Vector<A>, predicate: Predicate<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.
+ * @complexity O(n * log(m)), where n is the length of the outer Vector and m the length of the inner Vectors.
+ * @tsplus getter fncts.Vector flatten
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function flatten<A>(mma: Vector<Vector<A>>): Vector<A>;
+/**
+ * Converts an array, an array-like, or an iterable into a Vector.
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps from
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+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 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus getter fncts.Vector foldMap
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function foldMap_<A>(self: Vector<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+/**
+ * @tsplus getter fncts.Vector foldMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function foldMapWithIndex_<A>(self: Vector<A>): <M>(M: Monoid<M>) => (f: (i: number, a: A) => M) => M;
+/**
+ * Folds a function over a Vector. Right-associative.
+ * @complexity O(n)
+ * @tsplus fluent 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;
+/**
+ * Folds a function over a Vector. Right-associative.
+ * @complexity O(n)
+ * @tsplus fluent 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;
+/**
+ * Invokes a given callback for each element in the Vector from left to
+ * right. Returns `undefined`.
+ *
+ * This function is very similar to map. It should be used instead of
+ * `map` when the mapping function has side-effects. Whereas `map`
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function forEach_<A>(as: Vector<A>, f: (a: A) => void): void;
+/**
+ * @tsplus fluent 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;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function get_<A>(self: Vector<A>, index: number): Maybe<A>;
+/**
+ * Returns a Vector of Vectors where each subvector's elements are pairwise
+ * equal based on the given comparison function.
+ *
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function groupWith_<A>(as: Vector<A>, f: (a: A, b: A) => boolean): Vector<Vector<A>>;
+/**
+ * Returns the first element of the Vector.
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector head
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function indexOf_<A>(as: Vector<A>, element: A): number;
+/**
+ * Inserts the given element at the given index in the Vector.
+ * @complexity O(log(n))
+ * @tsplus fluent 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>;
+/**
+ * Inserts the given Vector of elements at the given index in the Vector.
+ * @complexity `O(log(n))`
+ * @tsplus fluent 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>;
+/**
+ * Inserts a separator between each element in a Vector.
+ * @tsplus fluent fncts.Vector intersperse
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function intersperse_<A>(as: Vector<A>, separator: 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;
+/**
+ * @tsplus fluent fncts.Vector isNonEmpty
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function isNonEmpty<A>(l: Vector<A>): boolean;
+/**
+ * Concatenates the strings in the Vector separated by a specified separator.
+ * @tsplus fluent fncts.Vector join
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function join_(as: Vector<string>, separator: 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>>;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function lastIndexOf_<A>(as: Vector<A>, element: A): number;
+/**
+ * Generates a new Vector by calling a function with the current index
+ * `n` times.
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps makeBy
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function makeBy<A>(n: number, f: (index: number) => A): Vector<A>;
+/**
+ * @tsplus fluent 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];
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function map_<A, B>(fa: Vector<A>, f: (a: A) => B): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function mapWithIndex_<A, B>(fa: Vector<A>, f: (i: number, a: A) => B): 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>;
+/**
+ * Returns a Vector that has the entry specified by the index replaced with
+ * the value returned by applying the function to the value.
+ *
+ * If the index is out of bounds the given Vector is
+ * returned unchanged.
+ * @complexity `O(log(n))`
+ * @tsplus fluent 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>;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function none_<A>(as: Vector<A>, predicate: Predicate<A>): boolean;
+/**
+ * Takes two arguments and returns a Vector that contains them.
+ * @complexity O(1)
+ * @tsplus static fncts.VectorOps pair
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function pair<A>(first: A, second: A): Vector<A>;
+/**
+ * Returns a new Vector with the last element removed. If the Vector is
+ * empty the empty Vector is returned.
+ * @complexity `O(1)`
+ * @tsplus getter fncts.Vector pop
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function pop<A>(as: 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function prepend_<A>(as: Vector<A>, a: A): Vector<A>;
+/**
+ * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps range
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function range(start: number, end: number): Vector<number>;
+/**
+ * Takes an index, a number of elements to remove and a Vector. Returns a
+ * new Vector with the given amount of elements removed from the specified
+ * index.
+ * @complexity `O(log(n))`
+ * @tsplus fluent 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>;
+/**
+ * Returns a Vector of a given length that contains the specified value
+ * in all positions.
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps replicate
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function replicate<A>(n: number, a: 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 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>;
+/**
+ * Takes a single arguments and returns a singleton Vector that contains it.
+ * @complexity O(1)
+ * @tsplus static fncts.VectorOps single
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function single<A>(a: A): Vector<A>;
+/**
+ * Returns a slice of a Vector. Elements are removed from the beginning and
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function slice_<A>(as: Vector<A>, from: number, to: number): Vector<A>;
+/**
+ * @tsplus getter fncts.Vector sort
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function sort_<A>(self: Vector<A>): (O: Ord<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
+ * first value is stricty larger than the second, `0` is they are
+ * equal and `1` if the first values is strictly smaller than the
+ * second.
+ * @complexity O(n * log(n))
+ * @tsplus fluent 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>;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function splitAt_<A>(as: Vector<A>, index: number): [Vector<A>, 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function splitWhen_<A>(as: Vector<A>, predicate: Predicate<A>): [Vector<A>, Vector<A>];
+/**
+ * Returns a new Vector with the first element removed. If the Vector is
+ * empty the empty Vector is returned.
+ * @complexity `O(1)`
+ * @tsplus getter fncts.Vector tail
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function tail<A>(as: 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function take_<A>(as: Vector<A>, n: number): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function takeWhile_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function takeLast_<A>(as: Vector<A>, n: number): 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function takeLastWhile_<A>(as: Vector<A>, predicate: Predicate<A>): Vector<A>;
+/**
+ * Converts a Vector into an array.
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector toArray
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function toArray<A>(self: Vector<A>): ReadonlyArray<A>;
+/**
+ * Converts a Vector into a List.
+ * @complexity `O(n)`
+ * @tsplus getter fncts.Vector toList
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function toList<A>(self: Vector<A>): List<A>;
+/**
+ * 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 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>;
+/**
+ * @tsplus static fncts.VectorOps unfold
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>): Vector<A>;
+/**
+ * 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unsafeFind_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unsafeFindLast_<A>(as: Vector<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unsafeGet_<A>(l: Vector<A>, index: number): A | undefined;
+/**
+ * Returns the first element of the Vector. If the Vector is empty the
+ * function returns undefined.
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector unsafeHead
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unsafeHead<A>(l: Vector<A>): A | undefined;
+/**
+ * Returns the last element of the Vector. If the Vector is empty the
+ * function returns `undefined`.
+ * @complexity O(1)
+ * @tsplus getter fncts.Vector unsafeLast
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unsafeLast<A>(l: 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 location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function updateAt_<A>(as: Vector<A>, i: number, a: A): Vector<A>;
+/**
+ * @tsplus static fncts.VectorOps __call
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function vector<A>(...elements: ReadonlyArray<A>): Vector<A>;

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

@@ -0,0 +1,66 @@
+import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
+export declare const VectorTypeId: unique symbol;
+export declare type VectorTypeId = typeof VectorTypeId;
+/**
+ * Represents a Vector of elements.
+ *
+ * @tsplus type fncts.Vector
+ * @tsplus companion fncts.VectorOps
+ */
+export declare class Vector<A> implements Iterable<A> {
+    /** @private */
+    readonly bits: number;
+    /** @private */
+    readonly offset: number;
+    readonly length: number;
+    /** @private */
+    readonly prefix: A[];
+    /** @private */
+    readonly root: Node | undefined;
+    /** @private */
+    readonly suffix: A[];
+    readonly _typeId: VectorTypeId;
+    constructor(
+    /** @private */
+    bits: number, 
+    /** @private */
+    offset: number, length: number, 
+    /** @private */
+    prefix: A[], 
+    /** @private */
+    root: Node | undefined, 
+    /** @private */
+    suffix: A[]);
+    [Symbol.iterator](): Iterator<A>;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.base.MutableVector
+ */
+export interface MutableVector<A> {
+    readonly _typeId: VectorTypeId;
+    bits: number;
+    offset: number;
+    length: number;
+    prefix: A[];
+    root: Node | undefined;
+    suffix: A[];
+    [Symbol.iterator]: () => Iterator<A>;
+    [Symbol.hash]: number;
+    [Symbol.equals](that: unknown): boolean;
+    /**
+     * This property doesn't exist at run-time. It exists to prevent a
+     * MutableVector from being assignable to a Vector.
+     */
+    "@@mutable": true;
+}
+export declare function isVector(u: unknown): u is Vector<unknown>;
+/**
+ * Returns true if the two Vectors are equivalent when comparing each
+ * pair of elements with the given comparison function.
+ * @complexity O(n)
+ * @tsplus fluent fncts.Vector corresponds
+ * @tsplus location "@fncts/base/collection/immutable/Vector/definition"
+ */
+export declare function corresponds_<A, B>(as: Vector<A>, bs: Vector<B>, f: (a: A, b: B) => boolean): boolean;