Rec

const Rec: object

Defined in: Data/Rec.ts:601

Type Declaration

compact

compact: <A>(data) => 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

data

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>(data) => readonly readonly [keyof T, T[keyof T]][]

Returns all key-value pairs of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

data

T

Returns

readonly readonly [keyof T, T[keyof T]][]

Example

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

filter

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

Filters values in a record by a predicate.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

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

Example

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

filterMap

filterMap: <A, B>(f) => (data) => 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

f

(a) => Maybe<B>

Returns

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

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) => (data) => Readonly<Record<string, A>>

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

Type Parameters

A

A

Parameters

predicate

(key, a) => boolean

Returns

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

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>(data) => Readonly<Record<string, A>>

Creates a record from key-value pairs.

Type Parameters

A

A

Parameters

data

readonly readonly [string, A][]

Returns

Readonly<Record<string, A>>

Example

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

groupBy

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

Groups elements of an array into a record keyed by the result of keyFn. 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

keyFn

(a) => 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>(data) => boolean

Returns true if the record has no keys.

Type Parameters

A

A

Parameters

data

Readonly<Record<string, A>>

Returns

boolean

Example

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

is.nonEmpty

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

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

Type Parameters

A

A

K

K extends string

Parameters

data

Readonly<Record<K, A>>

Returns

data is NonEmptyRecord<A, K>

Example

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

keys

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

Returns all keys of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

data

T

Returns

readonly keyof T & string[]

Example

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

lookup

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

Looks up a value by key, returning Maybe.

Type Parameters

K

K extends string

Parameters

key

K

Returns

<V>(data) => 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>(f) => <K>(data) => Readonly<Record<K, B>>

Transforms each value in a record.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

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

Example

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

mapEntries

mapEntries: <A, K2, B>(f) => (data) => Readonly<Record<K2, B>>

Transforms key and value pairs simultaneously.

Type Parameters

A

A

K2

K2 extends string

B

B

Parameters

f

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

Returns

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

Example

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

mapKeys

mapKeys: (f) => <A>(data) => Readonly<Record<string, A>>

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

Parameters

f

(key) => string

Returns

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

Example

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

mapWithKey

mapWithKey: <A, B>(f) => <K>(data) => Readonly<Record<K, B>>

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

Type Parameters

A

A

B

B

Parameters

f

(key, a) => B

Returns

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

Example

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

merge

merge: <A>(other) => (data) => 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

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

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

(a, b) => A

Returns

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

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

NonEmpty.entries

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

Type Parameters

K

K extends string

A

A

Parameters

data

NonEmptyRecord<A, K>

Returns

NonEmptyArr<readonly [K, A]>

NonEmpty.from

from: object

NonEmpty.from.Record

Record: <K, A>(data) => Maybe<NonEmptyRecord<A, K>>

Type Parameters

K

K extends string

A

A

Parameters

data

Readonly<Record<K, A>>

Returns

Maybe<NonEmptyRecord<A, K>>

NonEmpty.keys

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

Type Parameters

K

K extends string

A

A

Parameters

data

NonEmptyRecord<A, K>

Returns

NonEmptyArr<K>

NonEmpty.map

map: <A, B>(f) => <K>(data) => NonEmptyRecord<B, K>

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

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

NonEmpty.mapWithKey

mapWithKey: <A, B>(f) => <K>(data) => NonEmptyRecord<B, K>

Type Parameters

A

A

B

B

Parameters

f

(key, a) => B

Returns

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

NonEmpty.reduce

reduce: <A>(f) => <K>(data) => A

Type Parameters

A

A

Parameters

f

(acc, a) => A

Returns

<K>(data) => A

NonEmpty.singleton

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

Type Parameters

K

K extends string

A

A

Parameters

key

K

value

A

Returns

NonEmptyRecord<A, K>

NonEmpty.values

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

Type Parameters

K

K extends string

A

A

Parameters

data

NonEmptyRecord<A, K>

Returns

NonEmptyArr<A>

omit

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

Omits specific keys from a record.

Type Parameters

K

K extends string

Parameters

omittedKeys

…K[]

Returns

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

Example

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

pick

pick: <K>(…pickedKeys) => <A>(data) => Pick<A, K>

Picks specific keys from a record.

Type Parameters

K

K extends string

Parameters

pickedKeys

…K[]

Returns

<A>(data) => Pick<A, K>

Example

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

sequence

sequence: object

sequence.Maybe

Maybe: <A>(data) => Maybe<Readonly<Record<string, A>>> = RecMaybe.sequence

Sequence a record of Maybe values into a Maybe of a record. If any key contains None, the entire operation returns None.

Type Parameters

A

A

Parameters

data

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

Returns

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

Example

Rec.sequence.Maybe({ a: Maybe.make.some(1), b: Maybe.make.some(2) }); // Some({ a: 1, b: 2 })
Rec.sequence.Maybe({ a: Maybe.make.some(1), b: Maybe.make.none() }); // None

sequence.Result

Result: <E, A>(data) => Result<E, Readonly<Record<string, A>>> = RecResult.sequence

Sequence a record of Result values into a Result of a record. If any key contains an Err, the entire operation returns that Err.

Type Parameters

E

E

A

A

Parameters

data

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

Returns

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

Example

Rec.sequence.Result({ a: Result.make.ok(1), b: Result.make.ok(2) }); // Ok({ a: 1, b: 2 })
Rec.sequence.Result({ a: Result.make.ok(1), b: Result.make.err("oops") }); // Err("oops")

size

size: <A>(data) => number

Returns the number of keys in a record.

Type Parameters

A

A

Parameters

data

Readonly<Record<string, A>>

Returns

number

Example

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

to

to: object = RecTo

to.Dict

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

Type Parameters

A

A

K

K extends string = string

Parameters

data

Readonly<Record<K, A>>

Returns

ReadonlyMap<K, A>

traverse

traverse: object

traverse.Maybe

Maybe: <A, B>(f) => (data) => Maybe<Readonly<Record<string, B>>> = RecMaybe.traverse

Map a function that returns a Maybe over each value of a record, and combine the results into a single Maybe containing the updated record. If any value results in None, the entire operation returns None (short-circuits).

Type Parameters

A

A

B

B

Parameters

f

(a) => Maybe<B>

Returns

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

Example

const parseNum = (s: string) => s === "NaN" ? Maybe.make.none() : Maybe.make.some(Number(s));
pipe({ a: "1", b: "2" }, Rec.traverse.Maybe(parseNum)); // Some({ a: 1, b: 2 })
pipe({ a: "1", b: "NaN" }, Rec.traverse.Maybe(parseNum)); // None

traverse.Result

Result: <E, A, B>(f) => (data) => Result<E, Readonly<Record<string, B>>> = RecResult.traverse

Map a function that returns a Result over each value of a record, and combine the results into a single Result containing the updated record. If any value results in an Err, the entire operation returns that Err (short-circuits).

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => Result<E, B>

Returns

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

Example

const checkPositive = (n: number) => n < 0 ? Result.make.err("negative") : Result.make.ok(n);
pipe({ a: 1, b: 2 }, Rec.traverse.Result(checkPositive)); // Ok({ a: 1, b: 2 })
pipe({ a: 1, b: -2 }, Rec.traverse.Result(checkPositive)); // Err("negative")

updateIn

updateIn: <T>(path, f) => (data) => 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]

f

(val) => T

Returns

(data) => 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>(data) => readonly T[keyof T & string][]

Returns all values of a record.

Type Parameters

T

T extends Record<string, unknown>

Parameters

data

T

Returns

readonly T[keyof T & string][]

Example

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