@rimbu/sorted/dist/cjs/set-custom/implementation/immutable.d.cts

Immutable SortedMap and SortedSet implementations for TypeScript

import { type ArrayNonEmpty, IndexRange, OptLazy, Range, type RelatedTo, type ToJSON, TraverseState } from '@rimbu/common';
import { Stream, type StreamSource } from '@rimbu/stream';
import type { SortedSet } from '@rimbu/sorted/set';
import type { SortedSetContext } from '@rimbu/sorted/set-custom';
import { SortedEmpty, SortedNonEmptyBase } from '@rimbu/sorted/common';
export declare class SortedSetEmpty<T = any> extends SortedEmpty implements SortedSet<T> {
    readonly context: SortedSetContext<T>;
    _NonEmptyType: SortedSet.NonEmpty<T>;
    constructor(context: SortedSetContext<T>);
    streamRange(): Stream<T>;
    streamSliceIndex(): Stream<T>;
    has(): false;
    findIndex(): number;
    add(value: T): SortedSet.NonEmpty<T>;
    addAll(values: StreamSource<T>): SortedSet.NonEmpty<T>;
    remove(): this;
    removeAll(): this;
    slice(): this;
    union(other: StreamSource<T>): SortedSet<T> | any;
    difference(): SortedSet<T>;
    intersect(): SortedSet<T>;
    symDifference(other: StreamSource<T>): SortedSet<T>;
    toBuilder(): SortedSet.Builder<T>;
    toString(): string;
    toJSON(): ToJSON<T[]>;
}
export declare abstract class SortedSetNode<T> extends SortedNonEmptyBase<T, SortedSetNode<T>> implements SortedSet.NonEmpty<T> {
    _NonEmptyType: SortedSetNode<T>;
    abstract get context(): SortedSetContext<T>;
    abstract get size(): number;
    abstract stream(options?: {
        reversed?: boolean;
    }): Stream.NonEmpty<T>;
    abstract streamSliceIndex(range: IndexRange, options?: {
        reversed?: boolean;
    }): Stream<T>;
    abstract forEach(f: (value: T, index: number, halt: () => void) => void, options?: {
        state?: TraverseState;
    }): void;
    abstract has<U>(value: RelatedTo<T, U>): boolean;
    abstract findIndex(value: T): number;
    abstract min(): T;
    abstract max(): T;
    abstract toArray(): ArrayNonEmpty<T>;
    abstract addInternal(value: T): SortedSetNode<T>;
    abstract removeInternal(value: T): SortedSetNode<T>;
    abstract getInsertIndexOf(value: T): number;
    abstract normalize(): SortedSet<T>;
    asNormal(): this;
    getSliceRange(range: Range<T>): {
        startIndex: number;
        endIndex: number;
    };
    streamRange(range: Range<T>, options?: {
        reversed?: boolean;
    }): Stream<T>;
    add(value: T): SortedSet.NonEmpty<T>;
    addAll(values: StreamSource<T>): SortedSet.NonEmpty<T>;
    remove<U>(value: RelatedTo<T, U>): SortedSet<T>;
    removeAll<U>(values: StreamSource<RelatedTo<T, U>>): SortedSet<T>;
    filter(pred: (value: T, index: number, halt: () => void) => boolean, options?: {
        negate?: boolean | undefined;
    }): any;
    take(amount: number): SortedSet<T> | any;
    drop(amount: number): SortedSet<T>;
    sliceIndex(range: IndexRange): SortedSet<T>;
    slice(range: Range<T>): SortedSet<T>;
    union(other: StreamSource<T>): SortedSet<T> | any;
    difference(other: StreamSource<T>): SortedSet<T>;
    intersect(other: StreamSource<T>): SortedSet<T>;
    symDifference(other: StreamSource<T>): SortedSet<T>;
    toBuilder(): SortedSet.Builder<T>;
    toString(): string;
    toJSON(): ToJSON<T[]>;
}
export declare class SortedSetLeaf<T> extends SortedSetNode<T> {
    readonly context: SortedSetContext<T>;
    entries: readonly T[];
    constructor(context: SortedSetContext<T>, entries: readonly T[]);
    copy(entries: readonly T[]): SortedSetLeaf<T>;
    get size(): number;
    stream(options?: {
        reversed?: boolean;
    }): Stream.NonEmpty<T>;
    streamSliceIndex(range: IndexRange, options?: {
        reversed?: boolean;
    }): Stream<T>;
    min(): T;
    max(): T;
    has<U>(value: RelatedTo<T, U>): boolean;
    findIndex(value: T): number;
    getAtIndex<O>(index: number, otherwise?: OptLazy<O>): T | O;
    forEach(f: (value: T, index: number, halt: () => void) => void, options?: {
        state?: TraverseState;
    }): void;
    toArray(): ArrayNonEmpty<T>;
    getInsertIndexOf(value: T): number;
    addInternal(value: T): SortedSetNode<T>;
    removeInternal(value: T): SortedSetNode<T>;
    takeInternal(amount: number): SortedSetLeaf<T>;
    dropInternal(amount: number): SortedSetLeaf<T>;
    deleteMin(): [T, SortedSetLeaf<T>];
    deleteMax(): [T, SortedSetLeaf<T>];
    mutateSplitRight(index?: number): [T, SortedSetLeaf<T>];
    mutateGiveToLeft(left: SortedSetLeaf<T>, toLeft: T): [T, SortedSetLeaf<T>];
    mutateGiveToRight(right: SortedSetLeaf<T>, toRight: T): [T, SortedSetLeaf<T>];
    mutateGetFromLeft(left: SortedSetLeaf<T>, toMe: T): [T, SortedSetLeaf<T>];
    mutateGetFromRight(right: SortedSetLeaf<T>, toMe: T): [T, SortedSetLeaf<T>];
    mutateJoinLeft(left: SortedSetLeaf<T>, entry: T): void;
    mutateJoinRight(right: SortedSetLeaf<T>, entry: T): void;
    normalize(): SortedSet<T>;
}
export declare class SortedSetInner<T> extends SortedSetNode<T> {
    readonly context: SortedSetContext<T>;
    entries: readonly T[];
    children: readonly SortedSetNode<T>[];
    size: number;
    constructor(context: SortedSetContext<T>, entries: readonly T[], children: readonly SortedSetNode<T>[], size: number);
    get mutateChildren(): SortedSetNode<T>[];
    copy(entries?: readonly T[], children?: readonly SortedSetNode<T>[], size?: number): SortedSetInner<T>;
    stream(options?: {
        reversed?: boolean;
    }): Stream.NonEmpty<T>;
    streamSliceIndex(range: IndexRange, options?: {
        reversed?: boolean;
    }): Stream<T>;
    min(): T;
    max(): T;
    has<U>(value: RelatedTo<T, U>): boolean;
    findIndex(value: T): number;
    getAtIndex<O>(index: number, otherwise?: OptLazy<O>): T | O;
    forEach(f: (value: T, index: number, halt: () => void) => void, options?: {
        state?: TraverseState;
    }): void;
    toArray(): ArrayNonEmpty<T>;
    getInsertIndexOf(value: T): number;
    deleteMin(): [T, SortedSetInner<T>];
    deleteMax(): [T, SortedSetInner<T>];
    mutateSplitRight(index?: number): [T, SortedSetInner<T>];
    mutateGiveToLeft(left: SortedSetInner<T>, toLeft: T): [T, SortedSetInner<T>];
    mutateGiveToRight(right: SortedSetInner<T>, toRight: T): [T, SortedSetInner<T>];
    mutateGetFromLeft(left: SortedSetInner<T>, toMe: T): [T, SortedSetInner<T>];
    mutateGetFromRight(right: SortedSetInner<T>, toMe: T): [T, SortedSetInner<T>];
    mutateJoinLeft(left: SortedSetInner<T>, entry: T): void;
    mutateJoinRight(right: SortedSetInner<T>, entry: T): void;
    normalizeDownsizeChild(childIndex: number, newChild: SortedSetNode<T>, newSize: number): SortedSetInner<T>;
    normalizeIncreaseChild(childIndex: number, newChild: SortedSetNode<T>, newSize: number): SortedSetInner<T>;
    addInternal(value: T): SortedSetInner<T>;
    removeInternal(value: T): SortedSetNode<T>;
    takeInternal(amount: number): SortedSetNode<T>;
    dropInternal(amount: number): SortedSetNode<T>;
    normalize(): SortedSet<T>;
}