namespace HashMap
A type-invariant immutable 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 HashMap API documentation
Companion interface: HashMap<K,V>
Interfaces
| Name | Description |
|---|---|
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 |
HashMap.Context<UK> | A context instance for a HashMap that acts as a factory for every instance of this type of collection. |
HashMap.NonEmpty<K,V> | A non-empty type-invariant immutable 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 HashMap API documentation |
HashMap.Types | Utility interface that provides higher-kinded types for this collection. |
Static Methods
builder
Returns an empty builder instance for this type of collection and context.
builderDefinition
builder<K extends UK, V>(): WithKeyValue<Tp, K, V>['builder'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | |
| V |
HashMap.builder<number, string>() // => HashMap.Builder<number, string>
Overrides
createContext
Returns a new HashMap context instance based on the given options.
createContextoptions.Definition
createContext<UK>(options?: {
hasher?: Hasher<UK>;
eq?: Eq<UK>;
blockSizeBits?: number;
listContext?: List.Context;
}): HashMap.Context<UK>;
Type parameters
| Name | Description |
|---|---|
| UK | the upper key type for which the context can create instances |
Parameters
| Name | Type | Description |
|---|---|---|
options | {hasher?: Hasher<UK>;eq?: Eq<UK>;blockSizeBits?: number;listContext?: List.Context;} | (optional) an object containing the following properties: - hasher: (optional) a Hasher instance used to hash the map keys- eq: (optional) an Eq instance used to determine key equality- blockSizeBits: (optional) determines the maximum block size as 2 to the power of blockSizeBits- listContext: (optional) the context to use to create list instances (for collisions) |
defaultContext
Returns the default context for HashMaps.
defaultContextDefinition
defaultContext<UK>(): HashMap.Context<UK>;
Type parameters
| Name | Description |
|---|---|
| UK | the upper key type for which the context can create instances |
empty
Returns the (singleton) empty instance of this type and context with given key and value types.
emptyDefinition
empty<K extends UK, V>(): WithKeyValue<Tp, K, V>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | |
| V |
HashMap.empty<number, string>() // => HashMap<number, string>
HashMap.empty<string, boolean>() // => HashMap<string, boolean>
Overrides
from
Returns an immutable map of this type and context, containing the entries in the given sources StreamSource instances.
fromsources StreamSource instances.Definitions
from<K extends UK, V>(...sources: ArrayNonEmpty<StreamSource.NonEmpty<readonly [K, V]>>): WithKeyValue<Tp, K, V>['nonEmpty'];
from<K, V>(...sources: ArrayNonEmpty<StreamSource<readonly [K, V]>>): WithKeyValue<Tp, K, V>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | |
| V |
Parameters
| Name | Type | Description |
|---|---|---|
sources | ArrayNonEmpty<StreamSource.NonEmpty<readonly [K, V]>> | an array of StreamSource instances containing key-value entries |
HashMap.from([[1, 'a'], [2, 'b']]) // => HashMap.NonEmpty<number, string>
Overrides
merge
Returns a Map containing the common keys from this map and all the given sources key-value stream sources, and as values tuples of all the corresponding values for each common key. If a source doesn't have a key, the key will be skipped.
mergesources key-value stream sources, and as values tuples of all the corresponding values for each common key. If a source doesn't have a key, the key will be skipped.Definitions
merge<K extends UK, I extends readonly [unknown, unknown, ...unknown[]]>(...sources: {
[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;
} & unknown[]): WithKeyValue<Tp, K, {
[KT in keyof I]: I[KT];
}>['nonEmpty'];
merge<K extends UK, I extends readonly [unknown, unknown, ...unknown[]]>(...sources: {
[KT in keyof I]: StreamSource<readonly [K, I[KT]]>;
} & unknown[]): WithKeyValue<Tp, K, {
[KT in keyof I]: I[KT];
}>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | the common key type |
| I | readonly [unknown, unknown, ...unknown[]] | the array of input source value types |
Parameters
| Name | Type | Description |
|---|---|---|
sources | {[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;} & unknown[] | a non-empty set of StreamSouces containing tuples of keys and values |
const m = HashMap.of([1, 'a'], [2, 'b'])
const m2 = HashMap.merge(m, [[2, true]], HashMap.of([2, 15]))
// type of m2: HashMap<number, [string, boolean, number]>
console.log(m2.toArray())
// => [[2, ['b', true, 15]]]
Overrides
mergeAll
Returns a Map containing all keys from this map and all the given sources key-value stream sources, and as values tuples of all the corresponding values for each key. If a source doesn't have a key, the tuple will be filled with the given fillValue.
mergeAllsources key-value stream sources, and as values tuples of all the corresponding values for each key. If a source doesn't have a key, the tuple will be filled with the given fillValue.Definitions
mergeAll<O, I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(fillValue: O, ...sources: {
[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;
} & unknown[]): WithKeyValue<Tp, K, {
[KT in keyof I]: I[KT] | O;
}>['nonEmpty'];
mergeAll<O, I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(fillValue: O, ...sources: {
[KT in keyof I]: StreamSource<readonly [K, I[KT]]>;
} & unknown[]): WithKeyValue<Tp, K, {
[KT in keyof I]: I[KT] | O;
}>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| O | the type of the fill value | |
| I | readonly [unknown, unknown, ...unknown[]] | the array of input source value types |
| K | UK | the common key type |
Parameters
| Name | Type | Description |
|---|---|---|
fillValue | O | the value to use for the result tuple if a source does not have a certain key |
sources | {[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;} & unknown[] | a non-empty set of StreamSouces containing tuples of keys and values |
const m = HashMap.of([1, 'a'], [2, 'b'])
const m2 = HashMap.mergeAll('none', m, [[2, true]], HashMap.of([3, 15]))
// type of m2: HashMap<number, [string, boolean | string, number | string]>
console.log(m2.toArray())
// => [[1, ['a', 'none', 'none']], [2, ['b', true, 'none']], [3, ['none', 'none', 15]]]
Overrides
mergeAllWith
Returns a Map containing all keys from this map and all the given sources key-value stream sources, and as values the result of applying the given mergeFun to the key and all the corresponding values for each key. If a source doesn't have a key, the given tuple will be filled with the given fillValue.
mergeAllWithsources key-value stream sources, and as values the result of applying the given mergeFun to the key and all the corresponding values for each key. If a source doesn't have a key, the given tuple will be filled with the given fillValue.Definitions
mergeAllWith<I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(...sources: {
[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;
} & unknown[]): <O, R>(fillValue: O, mergeFun: (key: K, ...values: {
[KT in keyof I]: I[KT] | O;
}) => R) => WithKeyValue<Tp, K, R>['nonEmpty'];
mergeAllWith<I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(...sources: {
[KT in keyof I]: StreamSource<readonly [K, I[KT]]>;
} & unknown[]): <O, R>(fillValue: O, mergeFun: (key: K, ...values: {
[KT in keyof I]: I[KT] | O;
}) => R) => WithKeyValue<Tp, K, R>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| I | readonly [unknown, unknown, ...unknown[]] | the array of input source value types |
| K | UK | the common key type |
Parameters
| Name | Type | Description |
|---|---|---|
sources | {[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;} & unknown[] | a non-empty set of StreamSouces containing tuples of keys and values |
const m = HashMap.of([1, 'a'], [2, 'b'])
const m2 = HashMap.mergeAllWith(
m
[[2, 'c']],
HashMap.of([3, 'd'])
)(
'q',
(key, v1, v2, v3) => `${key}${v1}${v2}${v3}`
)
// type of m2: HashMap<number, string>
console.log(m2.toArray())
// => [[1, '1aqq'], [2, '2bcq'], [3, '3qqd']]
Overrides
mergeWith
Returns a Map containing the common keys from this map and all the given sources key-value stream sources, and as values the result of applying given mergeFun to the key and values of all the corresponding values for each common key. If a source doesn't have a key, the key will be skipped.
mergeWithsources key-value stream sources, and as values the result of applying given mergeFun to the key and values of all the corresponding values for each common key. If a source doesn't have a key, the key will be skipped.Definitions
mergeWith<I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(...sources: {
[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;
} & unknown[]): <R>(mergeFun: (key: K, ...values: I) => R) => WithKeyValue<Tp, K, R>['nonEmpty'];
mergeWith<I extends readonly [unknown, unknown, ...unknown[]], K extends UK>(...sources: {
[KT in keyof I]: StreamSource<readonly [K, I[KT]]>;
} & unknown[]): <R>(mergeFun: (key: K, ...values: I) => R) => WithKeyValue<Tp, K, R>['normal'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| I | readonly [unknown, unknown, ...unknown[]] | the array of input source value types |
| K | UK | the common key type |
Parameters
| Name | Type | Description |
|---|---|---|
sources | {[KT in keyof I]: StreamSource.NonEmpty<readonly [K, I[KT]]>;} & unknown[] | a non-empty set of StreamSouces containing tuples of keys and values |
const m = HashMap.of([1, 'a'], [2, 'b'])
const m2 = HashMap.mergeWith(
m,
[[2, true]],
HashMap.of([2, 15])
)(
(key, v1, v2) => `${key}${v1}${v2}`,
)
// type of m2: HashMap<number, string>
console.log(m2.toArray())
// => [[2, '2true15']]
Overrides
of
Returns an immutable map of this collection type and context, containing the given entries.
ofentries.Definition
of<K extends UK, V>(...entries: ArrayNonEmpty<readonly [K, V]>): WithKeyValue<Tp, K, V>['nonEmpty'];
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | |
| V |
Parameters
| Name | Type | Description |
|---|---|---|
entries | ArrayNonEmpty<readonly [K, V]> | a non-empty array of key-value entries |
HashMap.of([1, 'a'], [2, 'b']) // => HashMap.NonEmpty<number, string>
Overrides
reducer
Returns a Reducer that adds received tuples to an RMap and returns the RMap as a result. When a source is given, the reducer will first create an RMap from the source, and then add tuples to it.
reducerReducer that adds received tuples to an RMap and returns the RMap as a result. When a source is given, the reducer will first create an RMap from the source, and then add tuples to it.Definition
reducer<K extends UK, V>(source?: StreamSource<readonly [K, V]>): Reducer<readonly [K, V], WithKeyValue<Tp, K, V>['normal']>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| K | UK | |
| V |
Parameters
| Name | Type | Description |
|---|---|---|
source | StreamSource<readonly [K, V]> | (optional) an initial source of tuples to add to |
const someSource = HashMap.of([1, 'a'], [2, 'b']);
const result = Stream.of([1, 'c'], [3, 'a']).reduce(HashMap.reducer(someSource))
result.toArray() // => [[1, 'c'], [2, 'b'], [3, 'a']]
uses a builder under the hood. If the given source is an RMap in the same context, it will directly call .toBuilder().