Dict

const Dict: object

Defined in: Data/Dict.ts:607

Type Declaration

compact

compact: <K, A>(dict) => ReadonlyMap<K, A>

Removes all None values from a dictionary, unwrapping Some values.

Type Parameters

K

K

A

A

Parameters

dict

ReadonlyMap<K, Maybe<A>>

Returns

ReadonlyMap<K, A>

difference

difference: <K, V>(other) => (dict) => ReadonlyMap<K, V>

Returns a new dictionary containing keys from dict that are not in other.

Type Parameters

K

K

V

V

Parameters

other

ReadonlyMap<K, V>

Returns

(dict) => ReadonlyMap<K, V>

See

• union for combining all keys.
• intersection for keeping only common keys.

empty

empty: <K, V>() => ReadonlyMap<K, V>

Creates an empty dictionary.

Type Parameters

K

K

V

V

Returns

ReadonlyMap<K, V>

Example

const dict = Dict.empty<string, number>(); // ReadonlyMap {}

entries

entries: <K, V>(dict) => readonly (readonly [K, V])[]

Returns all key-value pairs of a dictionary.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

readonly (readonly [K, V])[]

See

• keys for extracting dictionary keys.
• values for extracting dictionary values.

filter

filter: <A>(predicate) => <K>(dict) => ReadonlyMap<K, A>

Filters dictionary entries by a predicate on values.

Type Parameters

A

A

Parameters

predicate

(value) => boolean

Returns

<K>(dict) => ReadonlyMap<K, A>

See

filterWithKey for filtering with key access.

filterMap

filterMap: <A, B>(transform) => <K>(dict) => ReadonlyMap<K, B>

Transforms values with a function returning Maybe, keeping only Some values.

Type Parameters

A

A

B

B

Parameters

transform

(value) => Maybe<B>

Returns

<K>(dict) => ReadonlyMap<K, B>

See

filter for filtering without transformation.

filterWithKey

filterWithKey: <K, A>(predicate) => (dict) => ReadonlyMap<K, A>

Filters dictionary entries by a predicate that also receives the key.

Type Parameters

K

K

A

A

Parameters

predicate

(key, value) => boolean

Returns

(dict) => ReadonlyMap<K, A>

See

filter for filtering values without key access.

from

from: object = DictFrom

from.entries

entries: <K, V>(entries) => ReadonlyMap<K, V>

Creates a dictionary from an array of key-value tuples.

Type Parameters

K

K

V

V

Parameters

entries

readonly (readonly [K, V])[]

Returns

ReadonlyMap<K, V>

Example

Dict.from.entries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }

from.nullable

nullable: <K, V>(dict) => Maybe<ReadonlyMap<K, V>>

Lifts a nullable dictionary into a Maybe. Returns None if null or undefined.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V> | null | undefined

Returns

Maybe<ReadonlyMap<K, V>>

Example

Dict.from.nullable(new Map([["a", 1]])); // Some(ReadonlyMap)
Dict.from.nullable(null);                 // None

from.record

record: <K, V>(record) => ReadonlyMap<K, V>

Creates a dictionary from a plain record.

Type Parameters

K

K extends string

V

V

Parameters

record

Readonly<Record<K, V>>

Returns

ReadonlyMap<K, V>

Example

Dict.from.record({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }

groupBy

groupBy: <A, K>(keySelector) => (items) => ReadonlyMap<K, NonEmptyArr<A>>

Groups elements of an array into a dictionary using a key selector function. Each key maps to a non-empty array of items that produced it.

Type Parameters

A

A

K

K

Parameters

keySelector

(item) => K

Returns

(items) => ReadonlyMap<K, NonEmptyArr<A>>

Example

pipe(["apple", "avocado", "banana"], Dict.groupBy(s => s[0]));
// ReadonlyMap { "a" => ["apple", "avocado"], "b" => ["banana"] }

has

has: <K>(key) => <V>(dict) => boolean

Returns true when the dictionary contains the specified key.

Type Parameters

K

K

Parameters

key

K

Returns

<V>(dict) => boolean

See

lookup for retrieving the value associated with a key.

insert

insert: <K, V>(key, value) => (dict) => ReadonlyMap<K, V>

Returns a new dictionary with the key set to value.

Type Parameters

K

K

V

V

Parameters

key

K

value

V

Returns

(dict) => ReadonlyMap<K, V>

See

• remove for deleting a key from a dictionary.
• upsert for conditional insertion/update.

intersection

intersection: <K, V>(other) => (dict) => ReadonlyMap<K, V>

Returns a new dictionary containing only keys present in both dictionaries.

Type Parameters

K

K

V

V

Parameters

other

ReadonlyMap<K, V>

Returns

(dict) => ReadonlyMap<K, V>

See

• union for combining all keys from both dictionaries.
• difference for subtracting keys.

is

is: object = DictIs

is.empty

empty: <K, V>(dict) => boolean

Returns true when the dictionary contains zero entries.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

boolean

See

nonEmpty for checking if a dictionary contains entries.

is.nonEmpty

nonEmpty: <K, V>(dict) => dict is NonEmptyMap<K, V>

Returns true when the dictionary contains at least one entry.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

dict is NonEmptyMap<K, V>

See

empty for checking if a dictionary is empty.

keys

keys: <K, V>(dict) => readonly K[]

Returns all keys of a dictionary.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

readonly K[]

See

• values for extracting dictionary values.
• entries for extracting key-value pairs.

lookup

lookup: <K>(key) => <V>(dict) => Maybe<V>

Retrieves the value associated with a key wrapped in a Maybe.

Type Parameters

K

K

Parameters

key

K

Returns

<V>(dict) => Maybe<V>

See

has for checking key existence without retrieving the value.

map

map: <A, B>(transform) => <K>(dict) => ReadonlyMap<K, B>

Transforms each value in the dictionary.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<K>(dict) => ReadonlyMap<K, B>

See

mapWithKey for transforming values with key access.

mapEntries

mapEntries: <K1, V1, K2, V2>(transform) => (dict) => ReadonlyMap<K2, V2>

Transforms key and value pairs simultaneously into a new dictionary.

Type Parameters

K1

K1

V1

V1

K2

K2

V2

V2

Parameters

transform

(key, value) => readonly [K2, V2]

Returns

(dict) => ReadonlyMap<K2, V2>

Example

pipe(
  Dict.from.entries([["a", 1]]),
  Dict.mapEntries((k, v) => [k.toUpperCase(), v * 10])
); // ReadonlyMap { "A" => 10 }

mapKeys

mapKeys: <K1, K2, V>(transform) => (dict) => ReadonlyMap<K2, V>

Transforms dictionary keys while preserving values.

Type Parameters

K1

K1

K2

K2

V

V

Parameters

transform

(key) => K2

Returns

(dict) => ReadonlyMap<K2, V>

Example

pipe(
  Dict.from.entries([["a", 1]]),
  Dict.mapKeys(k => k.toUpperCase())
); // ReadonlyMap { "A" => 1 }

mapWithKey

mapWithKey: <K, A, B>(transform) => (dict) => ReadonlyMap<K, B>

Transforms each value in the dictionary, also receiving the key.

Type Parameters

K

K

A

A

B

B

Parameters

transform

(key, value) => B

Returns

(dict) => ReadonlyMap<K, B>

See

map for transforming values without key access.

mergeWith

mergeWith: <V>(combine) => {<K>(first, second): ReadonlyMap<K, V>; <K>(second): (first) => ReadonlyMap<K, V>; }

Merges two dictionaries using a combination function on collisions. Supports both uncurried (first, second) and curried (second)(first) invocation.

Type Parameters

V

V

Parameters

combine

(first, second) => V

Returns

{<K>(first, second): ReadonlyMap<K, V>; <K>(second): (first) => ReadonlyMap<K, V>; }

Example

const mergeAdd = Dict.mergeWith((a: number, b: number) => a + b);
const d1 = Dict.from.entries([["a", 1], ["b", 2]]);
const d2 = Dict.from.entries([["b", 3], ["c", 4]]);
mergeAdd(d1, d2); // ReadonlyMap { "a" => 1, "b" => 5, "c" => 4 }
pipe(d1, mergeAdd(d2)); // ReadonlyMap { "a" => 1, "b" => 5, "c" => 4 }

NonEmpty

NonEmpty: object = DictNonEmptyConst

Utilities for working with guaranteed non-empty dictionaries (NonEmptyMap).

NonEmpty.entries

entries: <K, V>(dict) => NonEmptyArr<readonly [K, V]> = _nonEmptyEntries

Returns all entries of a non-empty dictionary as a NonEmptyArr.

Type Parameters

K

K

V

V

Parameters

dict

NonEmptyMap<K, V>

Returns

NonEmptyArr<readonly [K, V]>

Example

Dict.NonEmpty.entries(Dict.NonEmpty.singleton("a", 1)); // [["a", 1]]

NonEmpty.from

from: object

NonEmpty.from.map

map: <K, V>(dict) => Maybe<NonEmptyMap<K, V>> = _nonEmptyFromMap

Refines a standard Map to a NonEmptyMap, returning Some if size > 0, None otherwise.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

Maybe<NonEmptyMap<K, V>>

Example

Dict.NonEmpty.from.map(new Map([["a", 1]])); // Some(NonEmptyMap)
Dict.NonEmpty.from.map(new Map());           // None

NonEmpty.keys

keys: <K, V>(dict) => NonEmptyArr<K> = _nonEmptyKeys

Returns all keys of a non-empty dictionary as a NonEmptyArr.

Type Parameters

K

K

V

V

Parameters

dict

NonEmptyMap<K, V>

Returns

NonEmptyArr<K>

Example

Dict.NonEmpty.keys(Dict.NonEmpty.singleton("a", 1)); // ["a"]

NonEmpty.map

map: <A, B>(transform) => <K>(dict) => NonEmptyMap<K, B> = _nonEmptyMap

Transforms each value of a non-empty dictionary, preserving non-emptiness.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<K>(dict) => NonEmptyMap<K, B>

Example

pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.map(n => n * 2)); // NonEmptyMap { "a" => 2 }

NonEmpty.mapWithKey

mapWithKey: <K, A, B>(transform) => (dict) => NonEmptyMap<K, B> = _nonEmptyMapWithKey

Transforms each value with key access, preserving non-emptiness.

Type Parameters

K

K

A

A

B

B

Parameters

transform

(key, value) => B

Returns

(dict) => NonEmptyMap<K, B>

Example

pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.mapWithKey((k, v) => `${k}:${v}`));
// NonEmptyMap { "a" => "a:1" }

NonEmpty.reduce

reduce: <V>(reducer) => <K>(dict) => V = _nonEmptyReduce

Reduces values of a non-empty dictionary using the first value as initial accumulator.

Type Parameters

V

V

Parameters

reducer

(accumulator, value) => V

Returns

<K>(dict) => V

Example

pipe(Dict.NonEmpty.singleton("a", 5), Dict.NonEmpty.reduce((a, b) => a + b)); // 5

NonEmpty.singleton

singleton: <K, V>(key, value) => NonEmptyMap<K, V> = _nonEmptySingleton

Creates a NonEmptyMap containing a single entry.

Type Parameters

K

K

V

V

Parameters

key

K

value

V

Returns

NonEmptyMap<K, V>

Example

Dict.NonEmpty.singleton("a", 1); // NonEmptyMap { "a" => 1 }

NonEmpty.values

values: <K, V>(dict) => NonEmptyArr<V> = _nonEmptyValues

Returns all values of a non-empty dictionary as a NonEmptyArr.

Type Parameters

K

K

V

V

Parameters

dict

NonEmptyMap<K, V>

Returns

NonEmptyArr<V>

Example

Dict.NonEmpty.values(Dict.NonEmpty.singleton("a", 1)); // [1]

reduce

reduce: <B, V>(initial, reducer) => <K>(dict) => B

Reduces dictionary values from an initial value.

Type Parameters

B

B

V

V

Parameters

initial

B

reducer

(accumulator, value) => B

Returns

<K>(dict) => B

Example

pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.reduce(0, (acc, n) => acc + n)); // 3

reduceWithKey

reduceWithKey: <B, K, V>(initial, reducer) => (dict) => B

Reduces dictionary entries from an initial value, passing value and key to the reducer.

Type Parameters

B

B

K

K

V

V

Parameters

initial

B

reducer

(accumulator, value, key) => B

Returns

(dict) => B

Example

pipe(Dict.from.entries([["a", 1], ["b", 2]]), Dict.reduceWithKey("", (acc, v, k) => `${acc}${k}${v}`)); // "a1b2"

remove

remove: <K>(key) => <V>(dict) => ReadonlyMap<K, V>

Returns a new dictionary with the specified key removed.

Type Parameters

K

K

Parameters

key

K

Returns

<V>(dict) => ReadonlyMap<K, V>

See

insert for adding or replacing a key in a dictionary.

singleton

singleton: <K, V>(key, value) => ReadonlyMap<K, V>

Creates a dictionary with a single key-value entry.

Type Parameters

K

K

V

V

Parameters

key

K

value

V

Returns

ReadonlyMap<K, V>

Example

Dict.singleton("key", 42); // ReadonlyMap { "key" => 42 }

size

size: <K, V>(dict) => number

Returns the number of entries in the dictionary.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

number

Example

Dict.size(Dict.singleton("a", 1)); // 1

to

to: object = DictTo

to.record

record: <K, V>(dict) => Readonly<Record<K, V>>

Converts a dictionary to a plain record. Protects against prototype pollution when keys equal __proto__.

Type Parameters

K

K extends string

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

Readonly<Record<K, V>>

Example

Dict.to.record(Dict.from.entries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }

union

union: <K, V>(other) => (dict) => ReadonlyMap<K, V>

Combines two dictionaries, preferring entries from other on key collisions.

Type Parameters

K

K

V

V

Parameters

other

ReadonlyMap<K, V>

Returns

(dict) => ReadonlyMap<K, V>

See

• intersection for keeping only common keys.
• difference for removing keys present in the other dictionary.

upsert

upsert: <K, V>(key, update) => (dict) => ReadonlyMap<K, V>

Inserts or updates a key using a callback that receives the existing value if present.

Type Parameters

K

K

V

V

Parameters

key

K

update

(existing) => V

Returns

(dict) => ReadonlyMap<K, V>

See

insert for unconditional key setting.

values

values: <K, V>(dict) => readonly V[]

Returns all values of a dictionary.

Type Parameters

K

K

V

V

Parameters

dict

ReadonlyMap<K, V>

Returns

readonly V[]

See

• keys for extracting dictionary keys.
• entries for extracting key-value pairs.