interface HashMap.Builder<K,V>

A mutable HashMap builder used to efficiently create new immutable instances. See the Map documentation and the HashMap.Builder API documentation

Extends: RMapBase.Builder<K,V,Tp>

Implemented by: HashMapBlockBuilder<K,V>

Type parameters

Name	Description
K	the key type
V	the value type

Properties

context

Returns the context associated to this collection instance.

Definition

readonly context: WithKeyValue<Tp, K, V>['context'];

Overrides

Builder.context

isEmpty

Returns true if there are no entries in the builder.

Definition

readonly isEmpty: boolean;

example

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

Overrides

Builder.isEmpty

size

Returns the amount of entries in the builder.

Definition

readonly size: number;

example

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

Overrides

Builder.size

Methods

addEntries

Adds given entries to the builder.

Definition

addEntries(entries: StreamSource<readonly [K, V]>): boolean;

Parameters

Name	Type	Description
entries	StreamSource<readonly [K, V]>

example

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

Overrides

Builder.addEntries

addEntry

Adds given entry to the builder.

Definition

addEntry(entry: readonly [K, V]): boolean;

Parameters

Name	Type	Description
entry	readonly [K, V]

example

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

Overrides

Builder.addEntry

build

Returns an immutable collection instance containing the entries in this builder.

Definition

build(): WithKeyValue<Tp, K, V>['normal'];

example

const m = HashMap.of([1, 'a'], [2, 'b']).toBuilder()
const m2: HashMap<number, string> = m.build()

Overrides

Builder.build

buildMapValues

Returns an immutable instance of the entries in this builder, with given mapValues function applied to all the values in the entries.

Definition

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

Type parameters

Name	Description
V2

Parameters

Name	Type	Description
mapFun	(value: V, key: K) => V2	a function that takes an entry value and its key, and returns a new value

example

const m = HashMap.of([1, 'a'], [2, 'b']).toBuilder()
const m2: HashMap<number, number> = m.buildMapValues(value => value.length)

Overrides

Builder.buildMapValues

forEach

Performs given function f for each entry of the builder.

Definition

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

Parameters

Name	Type	Description
f	(entry: readonly [K, V], index: number, halt: () => void) => void	the function to perform for each element, receiving: - entry: the next key-value entry - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed
options	{       state?: TraverseState;     }

throws

RibuError.ModifiedBuilderWhileLoopingOverItError if the builder is modified while looping over it

example

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

note

O(N)

Overrides

Builder.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']).toBuilder()
m.get(2)          // => 'b'
m.get(3)          // => undefined
m.get(2, 'none')  // => 'b'
m.get(3, 'none')  // => 'none'

Overrides

Builder.get

hasKey

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

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']).toBuilder()
m.hasKey(2)    // => true
m.hasKey(3)    // => false

Overrides

Builder.hasKey

modifyAt

Modifies or creates the builder entry with given atKey as its key according to given options.

Definition

modifyAt(key: K, options: {
      ifNew?: OptLazyOr<V, Token>;
      ifExists?: (<V2 extends V = V>(currentValue: V & V2, remove: Token) => V |Token)| V;
    }): boolean;

Parameters

Name	Type	Description
key	K
options	{       ifNew?: OptLazyOr<V, Token>;       ifExists?: (<V2 extends V = V>(currentValue: V & V2, remove: Token) => V |Token)| V;     }

example

const m = HashMap.of([1, 'a'], [2, 'b']).toBuilder()
m.modifyAt(1, { ifNew: 'd' })
// => false
m.modifyAt(3, { ifNew: 'c' })
// => true
m.modifyAt(3, { ifNew: (none) => 1 < 2 ? none : 'c' })
// => false
m.modifyAt(2, { ifExists: () => 'c' })
// => true
m.modifyAt(1, { ifExists: (v) => v + 'z' })
// => true
m.modifyAt(2, { ifExists: (v, remove) => v === 'a' ? v : remove })
// => true

Overrides

Builder.modifyAt

removeKey

Removes the entry with given key from the builder.

Definitions

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

removeKey<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 of the entry to remove

example

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

Overrides

Builder.removeKey

removeKeys

Removes the entries in the given keys StreamSource from the builder.

Definition

removeKeys<UK = K>(keys: StreamSource<RelatedTo<K, UK>>): boolean;

Type parameters

Name	Default	Description
UK	K

Parameters

Name	Type	Description
keys	StreamSource<RelatedTo<K, UK>>

example

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

Overrides

Builder.removeKeys

set

Associates given key with given value in the builder.

Definition

set(key: K, value: V): boolean;

Parameters

Name	Type	Description
key	K	the entry key
value	V

example

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

Overrides

Builder.set

updateAt

Updates the value in the builder associated with given key according to given update value or function.

Definitions

updateAt(key: K, update: RMapBase.Update<V>): V | undefined;

updateAt<O>(key: K, update: RMapBase.Update<V>, otherwise: OptLazy<O>): V | O;

Parameters

Name	Type	Description
key	K	the key of the entry to update
update	RMapBase.Update<V>	a new value or function taking the previous value and returning a new value

example

const m = HashMap.of([1, 'a'], [2, 'b']).toBuilder()
m.updateAt(1, 'a')           // => 'a'
m.updateAt(1, 'b')           // => 'b'
m.updateAt(2, v => v + 'z')  // => 'b'

Overrides

Builder.updateAt