726 lines
18 KiB
TypeScript
726 lines
18 KiB
TypeScript
/**
|
|
* @since 2.0.0
|
|
*/
|
|
import type { Chunk } from "./Chunk.js"
|
|
import type { Equal } from "./Equal.js"
|
|
import type { Inspectable } from "./Inspectable.js"
|
|
import * as RBT from "./internal/redBlackTree.js"
|
|
import * as RBTI from "./internal/redBlackTree/iterator.js"
|
|
import type { Option } from "./Option.js"
|
|
import type { Order } from "./Order.js"
|
|
import type { Pipeable } from "./Pipeable.js"
|
|
import type * as Types from "./Types.js"
|
|
|
|
const TypeId: unique symbol = RBT.RedBlackTreeTypeId as TypeId
|
|
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
export type TypeId = typeof TypeId
|
|
|
|
/**
|
|
* @since 2.0.0
|
|
* @category constants
|
|
*/
|
|
export const Direction = RBTI.Direction
|
|
|
|
/**
|
|
* A Red-Black Tree.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
export interface RedBlackTree<in out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
|
|
readonly [TypeId]: {
|
|
readonly _Key: Types.Invariant<Key>
|
|
readonly _Value: Types.Covariant<Value>
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
export declare namespace RedBlackTree {
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
export type Direction = number & {
|
|
readonly Direction: unique symbol
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @since 2.0.0
|
|
* @category refinements
|
|
*/
|
|
export const isRedBlackTree: {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category refinements
|
|
*/
|
|
<K, V>(u: Iterable<readonly [K, V]>): u is RedBlackTree<K, V>
|
|
/**
|
|
* @since 2.0.0
|
|
* @category refinements
|
|
*/
|
|
(u: unknown): u is RedBlackTree<unknown, unknown>
|
|
} = RBT.isRedBlackTree
|
|
|
|
/**
|
|
* Creates an empty `RedBlackTree`.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export const empty: <K, V = never>(ord: Order<K>) => RedBlackTree<K, V> = RBT.empty
|
|
|
|
/**
|
|
* Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export const fromIterable: {
|
|
/**
|
|
* Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
<B>(ord: Order<B>): <K extends B, V>(entries: Iterable<readonly [K, V]>) => RedBlackTree<K, V>
|
|
/**
|
|
* Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
<K extends B, V, B>(entries: Iterable<readonly [K, V]>, ord: Order<B>): RedBlackTree<K, V>
|
|
} = RBT.fromIterable
|
|
|
|
/**
|
|
* Constructs a new `RedBlackTree` from the specified entries.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export const make: <K>(
|
|
ord: Order<K>
|
|
) => <Entries extends Array<readonly [K, any]>>(
|
|
...entries: Entries
|
|
) => RedBlackTree<K, Entries[number] extends readonly [any, infer V] ? V : never> = RBT.make
|
|
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const at: {
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<[K, V]>
|
|
} = RBT.atForwards
|
|
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const atReversed: {
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that points to the element at the specified index of the
|
|
* tree.
|
|
*
|
|
* **Note**: The iterator will run through elements in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<[K, V]>
|
|
} = RBT.atBackwards
|
|
|
|
/**
|
|
* Finds all values in the tree associated with the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
export const findAll: {
|
|
/**
|
|
* Finds all values in the tree associated with the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>
|
|
/**
|
|
* Finds all values in the tree associated with the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Chunk<V>
|
|
} = RBT.findAll
|
|
|
|
/**
|
|
* Finds the first value in the tree associated with the specified key, if it exists.
|
|
*
|
|
* @category elements
|
|
* @since 2.0.0
|
|
*/
|
|
export const findFirst: {
|
|
/**
|
|
* Finds the first value in the tree associated with the specified key, if it exists.
|
|
*
|
|
* @category elements
|
|
* @since 2.0.0
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>
|
|
/**
|
|
* Finds the first value in the tree associated with the specified key, if it exists.
|
|
*
|
|
* @category elements
|
|
* @since 2.0.0
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Option<V>
|
|
} = RBT.findFirst
|
|
|
|
/**
|
|
* Returns the first entry in the tree, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const first: <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]> = RBT.first
|
|
|
|
/**
|
|
* Returns the element at the specified index within the tree or `None` if the
|
|
* specified index does not exist.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
export const getAt: {
|
|
/**
|
|
* Returns the element at the specified index within the tree or `None` if the
|
|
* specified index does not exist.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
(index: number): <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]>
|
|
/**
|
|
* Returns the element at the specified index within the tree or `None` if the
|
|
* specified index does not exist.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, index: number): Option<[K, V]>
|
|
} = RBT.getAt
|
|
|
|
/**
|
|
* Gets the `Order<K>` that the `RedBlackTree<K, V>` is using.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const getOrder: <K, V>(self: RedBlackTree<K, V>) => Order<K> = RBT.getOrder
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const greaterThan: {
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.greaterThanForwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const greaterThanReversed: {
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.greaterThanBackwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const greaterThanEqual: {
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys greater than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.greaterThanEqualForwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const greaterThanEqualReversed: {
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys greater
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.greaterThanEqualBackwards
|
|
|
|
/**
|
|
* Finds the item with key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
export const has: {
|
|
/**
|
|
* Finds the item with key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean
|
|
/**
|
|
* Finds the item with key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
* @category elements
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): boolean
|
|
} = RBT.has
|
|
|
|
/**
|
|
* Insert a new item into the tree.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export const insert: {
|
|
/**
|
|
* Insert a new item into the tree.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>
|
|
/**
|
|
* Insert a new item into the tree.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K, value: V): RedBlackTree<K, V>
|
|
} = RBT.insert
|
|
|
|
/**
|
|
* Get all the keys present in the tree in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const keys: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<K> = RBT.keysForward
|
|
|
|
/**
|
|
* Get all the keys present in the tree in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const keysReversed: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<K> = RBT.keysBackward
|
|
|
|
/**
|
|
* Returns the last entry in the tree, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const last: <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]> = RBT.last
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const lessThan: {
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than the
|
|
* specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.lessThanForwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const lessThanReversed: {
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.lessThanBackwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const lessThanEqual: {
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in order with keys less than or
|
|
* equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.lessThanEqualForwards
|
|
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const lessThanEqualReversed: {
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
|
|
/**
|
|
* Returns an iterator that traverse entries in reverse order with keys less
|
|
* than or equal to the specified key.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
|
|
} = RBT.lessThanEqualBackwards
|
|
|
|
/**
|
|
* Execute the specified function for each node of the tree, in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const forEach: {
|
|
/**
|
|
* Execute the specified function for each node of the tree, in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
|
|
/**
|
|
* Execute the specified function for each node of the tree, in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, f: (key: K, value: V) => void): void
|
|
} = RBT.forEach
|
|
|
|
/**
|
|
* Visit each node of the tree in order with key greater then or equal to max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const forEachGreaterThanEqual: {
|
|
/**
|
|
* Visit each node of the tree in order with key greater then or equal to max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
|
|
/**
|
|
* Visit each node of the tree in order with key greater then or equal to max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void): void
|
|
} = RBT.forEachGreaterThanEqual
|
|
|
|
/**
|
|
* Visit each node of the tree in order with key lower then max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const forEachLessThan: {
|
|
/**
|
|
* Visit each node of the tree in order with key lower then max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
|
|
/**
|
|
* Visit each node of the tree in order with key lower then max.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void): void
|
|
} = RBT.forEachLessThan
|
|
|
|
/**
|
|
* Visit each node of the tree in order with key lower than max and greater
|
|
* than or equal to min.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const forEachBetween: {
|
|
/**
|
|
* Visit each node of the tree in order with key lower than max and greater
|
|
* than or equal to min.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(
|
|
options: {
|
|
readonly min: K
|
|
readonly max: K
|
|
readonly body: (key: K, value: V) => void
|
|
}
|
|
): (self: RedBlackTree<K, V>) => void
|
|
/**
|
|
* Visit each node of the tree in order with key lower than max and greater
|
|
* than or equal to min.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
<K, V>(
|
|
self: RedBlackTree<K, V>,
|
|
options: {
|
|
readonly min: K
|
|
readonly max: K
|
|
readonly body: (key: K, value: V) => void
|
|
}
|
|
): void
|
|
} = RBT.forEachBetween
|
|
|
|
/**
|
|
* Reduce a state over the entries of the tree.
|
|
*
|
|
* @since 2.0.0
|
|
* @category folding
|
|
*/
|
|
export const reduce: {
|
|
/**
|
|
* Reduce a state over the entries of the tree.
|
|
*
|
|
* @since 2.0.0
|
|
* @category folding
|
|
*/
|
|
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z
|
|
/**
|
|
* Reduce a state over the entries of the tree.
|
|
*
|
|
* @since 2.0.0
|
|
* @category folding
|
|
*/
|
|
<Z, V, K>(
|
|
self: RedBlackTree<K, V>,
|
|
zero: Z,
|
|
f: (accumulator: Z, value: V, key: K) => Z
|
|
): Z
|
|
} = RBT.reduce
|
|
|
|
/**
|
|
* Removes the entry with the specified key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export const removeFirst: {
|
|
/**
|
|
* Removes the entry with the specified key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>
|
|
/**
|
|
* Removes the entry with the specified key, if it exists.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<K, V>(self: RedBlackTree<K, V>, key: K): RedBlackTree<K, V>
|
|
} = RBT.removeFirst
|
|
|
|
/**
|
|
* Traverse the tree in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category traversing
|
|
*/
|
|
export const reversed: <K, V>(self: RedBlackTree<K, V>) => Iterable<[K, V]> = RBT.reversed
|
|
|
|
/**
|
|
* Returns the size of the tree.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const size: <K, V>(self: RedBlackTree<K, V>) => number = RBT.size
|
|
|
|
/**
|
|
* Get all values present in the tree in order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const values: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<V> = RBT.valuesForward
|
|
|
|
/**
|
|
* Get all values present in the tree in reverse order.
|
|
*
|
|
* @since 2.0.0
|
|
* @category getters
|
|
*/
|
|
export const valuesReversed: <K, V>(self: RedBlackTree<K, V>) => IterableIterator<V> = RBT.valuesBackward
|