Rec

const Rec: object

Defined in: Data/Rec.ts:704

Type Declaration

compact

compact: <A>(record) => Readonly<Record<string, A>>

Removes all None values from a Record<string, Maybe<A>>, returning a plain Record<string, A>. Useful when building records from fallible lookups.

Type Parameters

A

A

Parameters

record

Readonly<Record<string, Maybe<A>>>

Returns

Readonly<Record<string, A>>

Example

Rec.compact({ a: Maybe.make.some(1), b: Maybe.make.none(), c: Maybe.make.some(3) });
// { a: 1, c: 3 }

entries

entries: <T>(record) => readonly (readonly [keyof T, T[keyof T]])[]

Returns all key-value pairs of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

record

T

Returns

readonly (readonly [keyof T, T[keyof T]])[]

See

• keys for extracting record keys.
• values for extracting record values.

Example

Rec.entries({ a: 1, b: 2 }); // [["a", 1], ["b", 2]]

filter

filter: <A>(predicate) => (record) => Readonly<Record<string, A>>

Filters values in a record by a predicate.

Type Parameters

A

A

Parameters

predicate

(value) => boolean

Returns

(record) => Readonly<Record<string, A>>

See

• filterWithKey for filtering values with key access.
• filterMap for filtering and mapping in a single pass.

Example

pipe({ a: 1, b: 2, c: 3 }, Rec.filter(n => n > 1)); // { b: 2, c: 3 }

filterMap

filterMap: <A, B>(transform) => (record) => Readonly<Record<string, B>>

Maps each value in a record with a function returning a Maybe, keeping only Some values.

Type Parameters

A

A

B

B

Parameters

transform

(value) => Maybe<B>

Returns

(record) => Readonly<Record<string, B>>

See

filter for filtering with a boolean predicate.

Example

pipe(
  { a: 1, b: 2, c: 3 },
  Rec.filterMap((n) => (n % 2 === 0 ? Maybe.make.some(n * 10) : Maybe.make.none()))
); // { b: 20 }

filterWithKey

filterWithKey: <A>(predicate) => (record) => Readonly<Record<string, A>>

Filters values in a record by a predicate that also receives the key.

Type Parameters

A

A

Parameters

predicate

(key, value) => boolean

Returns

(record) => Readonly<Record<string, A>>

See

filter for filtering values without key access.

Example

pipe({ a: 1, b: 2, c: 3 }, Rec.filterWithKey((k, v) => k !== "a" && v > 0));
// { b: 2 }

from

from: object = RecFrom

from.entries

entries: <A>(pairs) => Readonly<Record<string, A>>

Creates a record from key-value pairs.

Type Parameters

A

A

Parameters

pairs

readonly (readonly [string, A])[]

Returns

Readonly<Record<string, A>>

Example

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

groupBy

groupBy: <A>(keySelector) => (items) => Readonly<Record<string, readonly A[]>>

Groups elements of an array into a record keyed by the result of keySelector. Each key maps to the array of elements that produced it, in insertion order.

Unlike Dict.groupBy, keys are always strings. Use Dict.groupBy when you need non-string keys or want to avoid the plain-object prototype chain.

Type Parameters

A

A

Parameters

keySelector

(item) => string

Returns

(items) => Readonly<Record<string, readonly A[]>>

Example

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

is

is: object = RecIs

is.empty

empty: <A>(record) => boolean

Returns true if the record has no keys.

Type Parameters

A

A

Parameters

record

Readonly<Record<string, A>>

Returns

boolean

See

nonEmpty for checking if a record has keys.

Example

Rec.is.empty({});       // true
Rec.is.empty({ a: 1 }); // false

is.nonEmpty

nonEmpty: <A, K>(record) => record is NonEmptyRecord<A, K> = _isNonEmpty

Type guard to check if a record is non-empty.

Type Parameters

A

A

K

K extends string

Parameters

record

Readonly<Record<K, A>>

Returns

record is NonEmptyRecord<A, K>

See

empty for checking if a record has no keys.

Example

Rec.is.nonEmpty({ a: 1 }); // true
Rec.is.nonEmpty({});       // false

keys

keys: <T>(record) => readonly (keyof T & string)[]

Returns all keys of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

record

T

Returns

readonly (keyof T & string)[]

See

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

Example

Rec.keys({ a: 1, b: 2 }); // ["a", "b"]

lookup

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

Looks up a value by key, returning Maybe.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<V>(record) => Maybe<V>

Example

pipe({ a: 1, b: 2 }, Rec.lookup("a")); // Some(1)
pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None

map

map: <A, B>(transform) => <K>(record) => Readonly<Record<K, B>>

Transforms each value in a record.

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<K>(record) => Readonly<Record<K, B>>

See

• mapWithKey for transforming values with key access.
• mapKeys for transforming keys while preserving values.
• mapEntries for transforming keys and values simultaneously.

Example

pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }

mapEntries

mapEntries: <A, K2, B>(transform) => (record) => Readonly<Record<K2, B>>

Transforms key and value pairs simultaneously.

Type Parameters

A

A

K2

K2 extends string

B

B

Parameters

transform

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

Returns

(record) => Readonly<Record<K2, B>>

See

• map for transforming values.
• mapKeys for transforming keys.

Example

pipe(
  { a: 1, b: 2 },
  Rec.mapEntries((k, v) => [k.toUpperCase(), v * 10])
); // { A: 10, B: 20 }

mapKeys

mapKeys: (transform) => <A>(record) => Readonly<Record<string, A>>

Transforms each key while preserving values. If two keys map to the same new key, the last one wins.

Parameters

transform

(key) => string

Returns

<A>(record) => Readonly<Record<string, A>>

See

• map for transforming values.
• mapEntries for transforming keys and values simultaneously.

Example

pipe({ firstName: "Alice", lastName: "Smith" }, Rec.mapKeys(k => k.toUpperCase()));
// { FIRSTNAME: "Alice", LASTNAME: "Smith" }

mapWithKey

mapWithKey: <A, B>(transform) => <K>(record) => Readonly<Record<K, B>>

Transforms each value in a record, also receiving the key.

Type Parameters

A

A

B

B

Parameters

transform

(key, value) => B

Returns

<K>(record) => Readonly<Record<K, B>>

See

map for transforming values without key access.

Example

pipe({ a: 1, b: 2 }, Rec.mapWithKey((k, v) => `${k}:${v}`));
// { a: "a:1", b: "b:2" }

merge

merge: <A>(other) => (record) => Readonly<Record<string, A>>

Merges two records. Values from the second record take precedence.

Type Parameters

A

A

Parameters

other

Readonly<Record<string, A>>

Returns

(record) => Readonly<Record<string, A>>

See

mergeWith for merging records with custom collision resolution.

Example

pipe({ a: 1, b: 2 }, Rec.merge({ b: 3, c: 4 })); // { a: 1, b: 3, c: 4 }

mergeWith

mergeWith: <A>(combine) => {(second): (first) => Readonly<Record<string, A>>; (first, second): Readonly<Record<string, A>>; }

Merges two records using a custom combination function on key collisions. Supports both uncurried Rec.mergeWith(combine)(first, second) and curried pipe(first, Rec.mergeWith(combine)(second)).

Type Parameters

A

A

Parameters

combine

(first, second) => A

Returns

{(second): (first) => Readonly<Record<string, A>>; (first, second): Readonly<Record<string, A>>; }

See

merge for shallow merging with right-precedence.

Example

const combineStats = Rec.mergeWith((a: number, b: number) => a + b);
combineStats({ a: 1, b: 2 }, { b: 3, c: 4 }); // { a: 1, b: 5, c: 4 }
pipe({ a: 1, b: 2 }, combineStats({ b: 3, c: 4 })); // { a: 1, b: 5, c: 4 }

NonEmpty

NonEmpty: object = RecNonEmpty

Utilities for working with guaranteed non-empty records (NonEmptyRecord).

NonEmpty.entries

entries: <K, A>(record) => NonEmptyArr<readonly [K, A]>

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

Type Parameters

K

K extends string

A

A

Parameters

record

NonEmptyRecord<A, K>

Returns

NonEmptyArr<readonly [K, A]>

Example

Rec.NonEmpty.entries({ a: 1, b: 2 } as Rec.NonEmpty<number>); // [["a", 1], ["b", 2]]

NonEmpty.from

from: object

NonEmpty.from.record

record: <K, A>(record) => Maybe<NonEmptyRecord<A, K>>

Refines a standard record to a NonEmptyRecord, returning Some if it has keys, None otherwise.

Type Parameters

K

K extends string

A

A

Parameters

record

Readonly<Record<K, A>>

Returns

Maybe<NonEmptyRecord<A, K>>

Example

Rec.NonEmpty.from.record({ a: 1 }); // Some({ a: 1 })
Rec.NonEmpty.from.record({});       // None

NonEmpty.keys

keys: <K, A>(record) => NonEmptyArr<K>

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

Type Parameters

K

K extends string

A

A

Parameters

record

NonEmptyRecord<A, K>

Returns

NonEmptyArr<K>

Example

Rec.NonEmpty.keys({ a: 1, b: 2 } as Rec.NonEmpty<number>); // ["a", "b"]

NonEmpty.map

map: <A, B>(transform) => <K>(record) => NonEmptyRecord<B, K>

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

Type Parameters

A

A

B

B

Parameters

transform

(value) => B

Returns

<K>(record) => NonEmptyRecord<B, K>

Example

pipe({ a: 1, b: 2 } as Rec.NonEmpty<number>, Rec.NonEmpty.map(n => n * 2)); // { a: 2, b: 4 }

NonEmpty.mapWithKey

mapWithKey: <A, B>(transform) => <K>(record) => NonEmptyRecord<B, K>

Transforms each value of a non-empty record with key access, preserving non-emptiness.

Type Parameters

A

A

B

B

Parameters

transform

(key, value) => B

Returns

<K>(record) => NonEmptyRecord<B, K>

Example

pipe({ a: 1, b: 2 } as Rec.NonEmpty<number>, Rec.NonEmpty.mapWithKey((k, v) => `${k}:${v}`));
// { a: "a:1", b: "b:2" }

NonEmpty.reduce

reduce: <A>(reducer) => <K>(record) => A

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

Type Parameters

A

A

Parameters

reducer

(accumulator, value) => A

Returns

<K>(record) => A

Example

pipe({ a: 1, b: 2 } as Rec.NonEmpty<number>, Rec.NonEmpty.reduce((x, y) => x + y)); // 3

NonEmpty.singleton

singleton: <K, A>(key, value) => NonEmptyRecord<A, K>

Creates a NonEmptyRecord containing a single key-value entry.

Type Parameters

K

K extends string

A

A

Parameters

key

K

value

A

Returns

NonEmptyRecord<A, K>

Example

Rec.NonEmpty.singleton("key", 42); // { key: 42 }

NonEmpty.values

values: <K, A>(record) => NonEmptyArr<A>

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

Type Parameters

K

K extends string

A

A

Parameters

record

NonEmptyRecord<A, K>

Returns

NonEmptyArr<A>

Example

Rec.NonEmpty.values({ a: 1, b: 2 } as Rec.NonEmpty<number>); // [1, 2]

omit

omit: <K>(…omittedKeys) => <A>(record) => Omit<A, K>

Omits specific keys from a record.

Type Parameters

K

K extends string

Parameters

omittedKeys

…readonly K[]

Returns

<A>(record) => Omit<A, K>

See

pick for retaining only specific keys from a record.

Example

pipe({ a: 1, b: 2, c: 3 }, Rec.omit("b")); // { a: 1, c: 3 }

pick

pick: <K>(…pickedKeys) => <A>(record) => Pick<A, K & keyof A>

Picks specific keys from a record.

Type Parameters

K

K extends string

Parameters

pickedKeys

…readonly K[]

Returns

<A>(record) => Pick<A, K & keyof A>

See

omit for removing specific keys from a record.

Example

pipe({ a: 1, b: 2, c: 3 }, Rec.pick("a", "c")); // { a: 1, c: 3 }

sequence

sequence: object

Sequences a record of effectful containers into a container of record.

sequence.Maybe

Maybe: <A>(record) => Maybe<Readonly<Record<string, A>>> = sequenceMaybe

Type Parameters

A

A

Parameters

record

Readonly<Record<string, Maybe<A>>>

Returns

Maybe<Readonly<Record<string, A>>>

sequence.Result

Result: <E, A>(record) => Result<E, Readonly<Record<string, A>>> = sequenceResult

Type Parameters

E

E

A

A

Parameters

record

Readonly<Record<string, Result<E, A>>>

Returns

Result<E, Readonly<Record<string, A>>>

size

size: <A>(record) => number

Returns the number of keys in a record.

Type Parameters

A

A

Parameters

record

Readonly<Record<string, A>>

Returns

number

Example

Rec.size({ a: 1, b: 2 }); // 2

to

to: object = RecTo

to.Dict

Dict: <A, K>(record) => ReadonlyMap<K, A>

Converts a record to a ReadonlyMap.

Type Parameters

A

A

K

K extends string = string

Parameters

record

Readonly<Record<K, A>>

Returns

ReadonlyMap<K, A>

Example

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

traverse

traverse: object

Maps record values to an effectful container and aggregates the results into a record.

traverse.Maybe

Maybe: <A, B>(transform) => (record) => Maybe<Readonly<Record<string, B>>> = traverseMaybe

Type Parameters

A

A

B

B

Parameters

transform

(value) => Maybe<B>

Returns

(record) => Maybe<Readonly<Record<string, B>>>

traverse.Result

Result: <E, A, B>(transform) => (record) => Result<E, Readonly<Record<string, B>>> = traverseResult

Type Parameters

E

E

A

A

B

B

Parameters

transform

(value) => Result<E, B>

Returns

(record) => Result<E, Readonly<Record<string, B>>>

updateIn

updateIn: <T>(path, transform) => (record) => Readonly<Record<string, unknown>>

Immutably updates a value at a deep nested path inside a record.

Type Parameters

T

T

Parameters

path

readonly [string, string]

transform

(value) => T

Returns

(record) => Readonly<Record<string, unknown>>

Example

pipe(
  { user: { profile: { age: 30 } } },
  Rec.updateIn(["user", "profile", "age"], (n: number) => n + 1)
); // { user: { profile: { age: 31 } } }

values

values: <T>(record) => readonly T[keyof T & string][]

Returns all values of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

record

T

Returns

readonly T[keyof T & string][]

See

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

Example

Rec.values({ a: 1, b: 2 }); // [1, 2]