interface VariantMap.NonEmpty<K,V>

A non-empty type-variant Map of key type K, and value type V. In the Map, each key has exactly one value, and the Map cannot contain duplicate keys. See the Map documentation and the VariantMap API documentation

Extends: VariantMap<K,V>, VariantMapBase.NonEmpty<K,V,Tp>

Type parameters

Name	Description
K	the 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

isEmpty

Returns false since this collection is known to be non-empty.

Definition

readonly isEmpty: false;

example

HashMap.of([1, 1], [2, 2]).isEmpty   // => false

Overrides

VariantMapBase.isEmptyNonEmpty.isEmpty

size

Returns the number of entries

Definition

readonly size: number;

example

HashMap.of([1, 1], [2, 2]).size       // => 2

Overrides

VariantMapBase.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]

asNormal

Returns this collection typed as a 'possibly empty' collection.

Definition

asNormal(): (Tp & KeyValue<K, V>)['normal'];

example

HashMap.of([1, 1], [2, 2]).asNormal();  // type: HashMap<number, number>

Overrides

NonEmpty.asNormal

assumeNonEmpty

Returns a self reference since this collection is known to be non-empty.

Definition

assumeNonEmpty(): this;

example

const m = HashMap.of([1, 1], [2, 2]);
m === m.assumeNonEmpty()  // => true

Overrides

VariantMapBase.assumeNonEmpty, NonEmpty.assumeNonEmpty

filter

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

Definition

filter(pred: (entry: readonly [K, V], index: number, halt: () => void) => boolean): WithKeyValue<Tp, K, V>['normal'];

Parameters

Name	Type	Description
pred	(entry: readonly [K, 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

HashMap.of([1, 'a'], [2, 'b'], [3, 'c']).filter(entry => entry[0] === 2 || entry[1] === 'c').toArray()
// => [[2, 'b'], [3, 'c']]

Overrides

VariantMapBase.filter

forEach

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

Definition

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

Parameters

Name	Type	Description
f	(entry: readonly [K, V], index: number, halt: () => void) => void	the function to perform for each entry, receiving: - entry: the next tuple of a 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

HashMap.of([1, 'a'], [2, 'b'], [3, 'c']).forEach((entry, i, halt) => {
console.log([entry[1], entry[0]]);
if (i >= 1) halt();
})
// => logs ['a', 1]  ['b', 2]

note

O(N)

Overrides

VariantMapBase.forEach

get

Returns the value associated with the given key, or given otherwise value if the key is not in the collection.

Definitions

get<UK = K>(key: RelatedTo<K, UK>): V | undefined;

get<UK, O>(key: RelatedTo<K, UK>, otherwise: OptLazy<O>): V | O;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key to look for

example

const m = HashMap.of([1, 'a'], [2, 'b'])
m.get(2)          // => 'b'
m.get(3)          // => undefined
m.get(2, 'none')  // => 'b'
m.get(3, 'none')  // => 'none'

Overrides

VariantMapBase.get

hasKey

Returns true if the given key is present in the collection.

Definition

hasKey<UK = K>(key: RelatedTo<K, UK>): boolean;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key to look for

example

const m = HashMap.of([1, 'a'], [2, 'b'])
m.hasKey(2)    // => true
m.hasKey(3)    // => false

Overrides

VariantMapBase.hasKey

mapValues

Returns a non-empty collection with the same keys, but where the given mapFun function is applied to each entry value.

Definition

mapValues<V2>(mapFun: (value: V, key: K) => V2): (Tp & KeyValue<K, V2>)['nonEmpty'];

Type parameters

Name	Description
V2

Parameters

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

example

HashMap.of([1, 'a'], [2, 'abc']).mapValues(v => v.length).toArray()
// => [[1, 1], [2, 3]]

Overrides

VariantMapBase.mapValues, NonEmpty.mapValues

nonEmpty

Returns true since this collection is known to be non-empty

Definition

nonEmpty(): true;

example

HashMap.of([1, 1], [2, 2]).nonEmpty()   // => true

Overrides

VariantMapBase.nonEmpty, NonEmpty.nonEmpty

removeKey

Returns the collection where the entry associated with given key is removed if it was part of the collection.

Definition

removeKey<UK = K>(key: RelatedTo<K, UK>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of the entry to remove

example

const m = HashMap.of([1, 'a'], [2, 'b'])
m.removeKey(2).toArray()   // => [[1, 'a']]
m.removeKey(3) === m       // true

note

guarantees same object reference if the key is not present

Overrides

VariantMapBase.removeKey

removeKeyAndGet

Returns a tuple containing the collection of which the entry associated with given key is removed, and the value that is associated with that key. If the key is not present, it will return undefined instead.

Definition

removeKeyAndGet<UK = K>(key: RelatedTo<K, UK>): [WithKeyValue<Tp, K, V>['normal'], V] | undefined;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
key	RelatedTo<K, UK>	the key of the entry to remove

example

const m = HashMap.of([1, 'a'], [2, 'b'])
const result = m.removeKeyAndGet(2)
if (result !== undefined) console.log([result[0].toString(), result[1]])    // => logs [HashMap(1 => 'a'), 'b']
console.log(m.removeKeyAndGet(3))                                           // => logs undefined

Overrides

VariantMapBase.removeKeyAndGet

removeKeys

Returns the collection where the entries associated with each key in given keys are removed if they were present.

Definition

removeKeys<UK = K>(keys: StreamSource<RelatedTo<K, UK>>): WithKeyValue<Tp, K, V>['normal'];

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
keys	StreamSource<RelatedTo<K, UK>>	a StreamSource of keys to remove

example

const m = HashMap.of([1, 'a'], [2, 'b'])
m.removeKeys([1, 3]).toArray()     // => [[2, 'b']]
m.removeKeys([1, 3, 2]).toArray()  // => []
m.removeKeys([3, 4, 5]) === m      // => true

note

guarantees same object reference if none of the keys are present

Overrides

VariantMapBase.removeKeys

stream

Returns a non-empty Stream containing all entries of this collection as tuples of key and value.

Definition

stream(): Stream.NonEmpty<readonly [K, V]>;

example

HashMap.of([1, 1], [2, 2]).stream().toArray()  // => [[1, 1], [2, 2]]

Overrides

NonEmpty.stream, VariantMapBase.stream, NonEmpty.stream

streamKeys

Returns a non-empty Stream containing all keys of this collection.

Definition

streamKeys(): Stream.NonEmpty<K>;

example

HashMap.of([[1, 'a'], [2, 'b']]).streamKeys().toArray()   // => [1, 2]

Overrides

VariantMapBase.streamKeys, NonEmpty.streamKeys

streamValues

Returns a non-empty Stream containing all values of this collection.

Definition

streamValues(): Stream.NonEmpty<V>;

example

HashMap.of([[1, 'a'], [2, 'b']]).streamValues().toArray()   // => ['a', 'b']

Overrides

VariantMapBase.streamValues, NonEmpty.streamValues

toArray

Returns a non-empty array containing all entries in this collection.

Definition

toArray(): ArrayNonEmpty<readonly [K, V]>;

example

HashMap.of([1, 'a'], [2, 'b']).toArray()   // => [[1, 'a'], [2, 'b']]

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

VariantMapBase.toArray, NonEmpty.toArray

toJSON

Returns a JSON representation of this collection.

Definition

toJSON(): ToJSON<(readonly [K, V])[]>;

example

HashMap.of([1, 'a'], [2, 'b']).toJSON()   // => { dataType: 'HashMap', value: [[1, 'a'], [2, 'b']] }

Overrides

VariantMapBase.toJSON

toString

Returns a string representation of this collection.

Definition

toString(): string;

example

HashMap.of([1, 'a'], [2, 'b']).toString()   // => HashMap(1 => 'a', 2 => 'b')

Overrides

VariantMapBase.toString