interface VariantTable<R,C,V>

A type-variant immutable Table of row key type R, column key type C, and value type V. In the Table, a combination of a row and column key has exactly one value. See the Table documentation and the VariantTable API documentation

Companion namespace: VariantTable

Extends: VariantTableBase<R,C,V,Tp>

Type parameters

Name	Description
R	the row key type
C	the column key type
V	the value type

note

Type-variance means that both the key and value types can be widened in a type-safe way without casting. @note As a consequence of being variant, the type does not contain methods that (can) add new elements to the collection.

Properties

amountRows

Returns the amount of rows in the collection.

Definition

readonly amountRows: number;

example

HashTableHashColumn.empty<number, number, number>().rowSize   // => 0
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).rowSize          // => 1

Overrides

VariantTableBase.amountRows

isEmpty

Returns true if the collection is empty.

Definition

readonly isEmpty: boolean;

example

HashTableHashColumn.empty<number, number, number>().isEmpty   // => true
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).isEmpty          // => false

Overrides

VariantTableBase.isEmpty

rowMap

Returns the Map representation of this collection.

Definition

readonly rowMap: WithRow<Tp, R, C, V>['rowMap'];

example

const m = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
const map: HashMap<number, HashMap.NonEmpty<number, number>> = m.rowMap

Overrides

VariantTableBase.rowMap

size

Returns the amount of entries in the collection.

Definition

readonly size: number;

example

HashTableHashColumn.empty<number, number, number>().size   // => 0
HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).size          // => 2

Overrides

VariantTableBase.size

Methods

[Symbol.iterator]

Returns a FastIterator instance used to iterate over the values of this Iterable.

Definition

[Symbol.iterator](): FastIterator<T>;

Overrides

FastIterable.[Symbol.iterator]

assumeNonEmpty

Returns the collection as a .NonEmpty type

Definition

assumeNonEmpty(): WithRow<Tp, R, C, V>['nonEmpty'];

throws

RimbuError.EmptyCollectionAssumedNonEmptyError if the collection is empty

example

HashTableHashColumn.empty<number, number, number>().assumeNonEmpty()   // => throws
const m: Table<number, number, number> = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
const m2: Table.NonEmpty<number, number> = m     // => compiler error
const m3: Table.NonEmpty<number, number> = m.assumeNonEmpty()

note

returns reference to this collection

Overrides

VariantTableBase.assumeNonEmpty

filter

Returns a collection containing only those entries that satisfy given pred predicate.

Definition

filter(pred: (entry: [R, C, V], index: number, halt: () => void) => boolean): WithRow<Tp, R, C, V>['normal'];

Parameters

Name	Type	Description
pred	(entry: [R, C, V], index: number, halt: () => void) => boolean	a predicate function receiving: - entry: the next entry - index: the entry index - halt: a function that, when called, ensures no next elements are passed

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.filter(entry => entry[2] === 5).toArray()
// => [[1, 4, 5], [2, 3, 5]]

Overrides

VariantTableBase.filter

filterRows

Returns a collection containing only those rows that satisfy given pred predicate.

Definition

filterRows(pred: (entry: readonly [R, WithRow<Tp, R, C, V>['rowNonEmpty']], index: number, halt: () => void) => boolean): WithRow<Tp, R, C, V>['normal'];

Parameters

Name	Type	Description
pred	(entry: readonly [R, WithRow<Tp, R, C, V>['rowNonEmpty']], index: number, halt: () => void) => boolean	a predicate function receiving: - entry: the next entry of the row key and a collection representing its columns and values - index: the entry index - halt: a function that, when called, ensures no next elements are passed

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.filterRows((rowKey, values) => rowKey === 1 && values.hasKey(4)).toArray()
// => [[1, 2, 3], [1, 4, 5]]

Overrides

VariantTableBase.filterRows

forEach

Performs given function f for each entry of the collection, using given state as initial traversal state.

Definition

forEach(f: (entry: [R, C, V], index: number, halt: () => void) => void, state?: TraverseState): void;

Parameters

Name	Type	Description
f	(entry: [R, C, V], index: number, halt: () => void) => void	the function to perform for each entry, receiving: - entry: the next tuple of a row key, column key, and value - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed
state	TraverseState	(optional) the traverse state

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.forEach((entry, i, halt) => {
console.log([entry]);
if (i >= 1) halt();
})
// => logs [1, 2, 3]  [1, 4, 5]

note

O(N)

Overrides

VariantTableBase.forEach

get

Returns the value at given row and column keys, or the otherwise value if no value is present.

Definitions

get<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): V | undefined;

get<UR, UC, O>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>, otherwise: OptLazy<O>): V | O;

Type parameters

Name	Default	Description
UR	R
UC	C

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key
column	RelatedTo<C, UC>	the column key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.get(10, 1)     // => undefined
t.get(10, 1, 0)  // => 0
t.get(1, 2)      // => 3
t.get(1, 2, 0)   // => 3

Overrides

VariantTableBase.get

getRow

Returns a map containing the column keys and values in the given row.

Definition

getRow<UR = R>(row: RelatedTo<R, UR>): WithRow<Tp, R, C, V>['row'];

Type parameters

Name	Default	Description
UR	R

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.getRow(10).toArray()    // => []
t.getRow(1).toArray()     // => [[2, 3], [4, 5]]

Overrides

VariantTableBase.getRow

hasRowKey

Returns true if given row key is in the collection.

Definition

hasRowKey<UR = R>(row: RelatedTo<R, UR>): boolean;

Type parameters

Name	Default	Description
UR	R

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key to look for

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.hasRowKey(10)    // => false
t.hasRowKey(1)     // => true

Overrides

VariantTableBase.hasRowKey

hasValueAt

Returns true if the collection has a value for given row and column keys.

Definition

hasValueAt<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): boolean;

Type parameters

Name	Default	Description
UR	R
UC	C

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key
column	RelatedTo<C, UC>	the column key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.hasValueAt(10, 1)    // => false
t.hasValueAt(1, 4)     // => true

Overrides

VariantTableBase.hasValueAt

mapValues

Returns a collection with the same row and column keys, but where the given mapFun function is applied to each entry value.

Definition

mapValues<V2>(mapFun: (value: V, row: R, column: C) => V2): (Tp & Row<R, C, V2>)['normal'];

Type parameters

Name	Description
V2

Parameters

Name	Type	Description
mapFun	(value: V, row: R, column: C) => V2	a function taking a value and a row and column key, and returning a new value

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 3, 5])
.mapValues(value => value * 2)
// => [[1, 2, 6], [1, 4, 10], [2, 3, 10]]

Overrides

VariantTableBase.mapValues

nonEmpty

Returns true if there is at least one entry in the collection, and instructs the compiler to treat the collection as a .NonEmpty type.

Definition

nonEmpty(): this is WithRow<Tp, R, C, V>['nonEmpty'];

example

const m: Table<number, number> = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
m.stream().first(0)     // compiler allows fallback value since the Stream may be empty
if (m.nonEmpty()) {
m.stream().first(0)   // compiler error: fallback value not allowed since Stream is not empty
}

Overrides

VariantTableBase.nonEmpty

remove

Returns the collection where the value at given row and column keys is removed.

Definition

remove<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): WithRow<Tp, R, C, V>['normal'];

Type parameters

Name	Default	Description
UR	R
UC	C

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key
column	RelatedTo<C, UC>	the column key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.remove(10, 11).toArray()   // => [[1, 2, 3], [1, 4, 5]]
t.remove(1, 4).toArray()     // => [[1, 2, 3]]

Overrides

VariantTableBase.remove

removeAndGet

Returns a tuple containing the collection with the value at given row and column removed, and the removed value. If no such value is found, it returns undefined.

Definition

removeAndGet<UR = R, UC = C>(row: RelatedTo<R, UR>, column: RelatedTo<C, UC>): [WithRow<Tp, R, C, V>['normal'], V] | undefined;

Type parameters

Name	Default	Description
UR	R
UC	C

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key
column	RelatedTo<C, UC>	the column key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeAndGet(10, 11)  // => undefined
t.removeAndGet(1, 2)    // => [HashTableHashColumn([1, 4, 5]), 3]

Overrides

VariantTableBase.removeAndGet

removeEntries

Returns the collection where the given entries are removed.

Definition

removeEntries<UR = R, UC = C>(entries: StreamSource<[RelatedTo<R, UR>, RelatedTo<C, UC>]>): WithRow<Tp, R, C, V>['normal'];

Type parameters

Name	Default	Description
UR	R
UC	C

Parameters

Name	Type	Description
entries	StreamSource<[RelatedTo<R, UR>, RelatedTo<C, UC>]>	a StreamSource of table entries

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeEntries([[6, 7, 8], [7, 8, 9]]).toArray()  // => [[1, 2, 3], [1, 4, 5]]
t.removeEntries([[6, 7, 8], [1, 2, 3]]).toArray()  // => [[1, 4, 5]]

Overrides

VariantTableBase.removeEntries

removeRow

Returns the collection where all values in given row are removed.

Definition

removeRow<UR = R>(row: RelatedTo<R, UR>): WithRow<Tp, R, C, V>['normal'];

Type parameters

Name	Default	Description
UR	R

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5], [2, 2, 3])
t.removeRow(10).toArray()   // => [[1, 2, 3], [1, 4, 5], [2, 2, 3]]
t.removeRow(1).toArray()    // => [[2, 2, 3]]

Overrides

VariantTableBase.removeRow

removeRowAndGet

Returns a tuple containing the collection with the values at given row removed, and a map containing the removed columns and values. If no such row is found, it returns undefined.

Definition

removeRowAndGet<UR = R>(row: RelatedTo<R, UR>): [WithRow<Tp, R, C, V>['normal'], WithRow<Tp, R, C, V>['rowNonEmpty']] | undefined;

Type parameters

Name	Default	Description
UR	R

Parameters

Name	Type	Description
row	RelatedTo<R, UR>	the row key

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeRowAndGet(10)    // => undefined
t.removeRowAndGet(1)     // => [HashTableHashColumn(), HashMap(2 => 3, 4 => 5)]

Overrides

VariantTableBase.removeRowAndGet

removeRows

Returns the collection where the values for each row key in given rows are removed.

Definition

removeRows<UR = R>(rows: StreamSource<RelatedTo<R, UR>>): WithRow<Tp, R, C, V>['normal'];

Type parameters

Name	Default	Description
UR	R

Parameters

Name	Type	Description
rows	StreamSource<RelatedTo<R, UR>>	a StreamSource of row keys

example

const t = HashTableHashColumn.of([1, 2, 3], [1, 4, 5])
t.removeRows([10, 11]).toArray()   // => [[1, 2, 3], [1, 4, 5]]
t.removeRows([1, 10]).toArray()    // => []

Overrides

VariantTableBase.removeRows

stream

Returns a Stream containing all entries of this collection as tuples of row key, column key, and value.

Definition

stream(): Stream<[R, C, V]>;

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).stream().toArray()
// => [[1, 2, 3], [1, 4, 5]]

Overrides

VariantTableBase.stream

streamRows

Returns a Stream containing all row keys of this collection.

Definition

streamRows(): Stream<R>;

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).streamRows().toArray()
// => [1]

Overrides

VariantTableBase.streamRows

streamValues

Returns a Stream containing all values of this collection.

Definition

streamValues(): Stream<V>;

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).streamValues().toArray()
// => [3, 5]

Overrides

VariantTableBase.streamValues

toArray

Returns an array containing all entries in this collection.

Definition

toArray(): [R, C, V][];

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toArray()
// => [[1, 2, 3], [1, 4, 5]]

note

O(log(N)) @note it is safe to mutate the returned array, however, the array elements are not copied, thus should be treated as read-only

Overrides

VariantTableBase.toArray

toJSON

Returns a JSON representation of this collection.

Definition

toJSON(): ToJSON<[R, [C, V][]][]>;

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toJSON()
// => { dataType: 'HashTableHashColumn', value: [1, [ [2, 3], [4, 5] ] ] }

Overrides

VariantTableBase.toJSON

toString

Returns a string representation of this collection.

Definition

toString(): string;

example

HashTableHashColumn.of([1, 2, 3], [1, 4, 5]).toString()
// => HashTableHashColumn([1, 2] -> 3, [1, 4] -> 5)

Overrides

VariantTableBase.toString