<K extends string, A>(equivalence: Equivalence<A>): Equivalence<
ReadonlyRecord<K, A>
>Create an Equivalence for records using the provided Equivalence for values.
Two records are considered equivalent if they have the same keys and their corresponding values are equivalent.
Example (Comparing records with a value equivalence)
import { Equal, Record } from "effect"
import * as assert from "node:assert"
const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence<number>())
assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }), true)
assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }), false)export const const makeEquivalence: <
K extends string,
A
>(
equivalence: Equivalence<A>
) => Equivalence<ReadonlyRecord<K, A>>
Create an Equivalence for records using the provided Equivalence for values.
Two records are considered equivalent if they have the same keys and their corresponding values are equivalent.
Example (Comparing records with a value equivalence)
import { Equal, Record } from "effect"
import * as assert from "node:assert"
const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence<number>())
assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }), true)
assert.deepStrictEqual(recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }), false)
makeEquivalence = <function (type parameter) K in <K extends string, A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<K, A>>K extends string, function (type parameter) A in <K extends string, A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<K, A>>A>(
equivalence: Equivalence<A>equivalence: import EquivalenceEquivalence<function (type parameter) A in <K extends string, A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<K, A>>A>
): import EquivalenceEquivalence<type ReadonlyRecord<in out K extends string | symbol, out A> = { readonly [P in K]: A; }Represents a readonly record with keys of type K and values of type A.
This is the foundational type for immutable key-value mappings in Effect.
Example (Defining a readonly record type)
import type { Record } from "effect"
// Creating a readonly record type
type UserRecord = Record.ReadonlyRecord<"name" | "age", string | number>
const user: UserRecord = {
name: "John",
age: 30
}
Namespace containing utility types for working with readonly records.
These types help with type-level operations on record keys and values.
Example (Using readonly record helper types)
import type { Record } from "effect"
// Using NonLiteralKey to convert literal keys to generic types
type GenericKey = Record.ReadonlyRecord.NonLiteralKey<"foo" | "bar"> // string
// Using IntersectKeys to find common keys between record types
type CommonKeys = Record.ReadonlyRecord.IntersectKeys<"a" | "b", "b" | "c"> // "b"
ReadonlyRecord<function (type parameter) K in <K extends string, A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<K, A>>K, function (type parameter) A in <K extends string, A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<K, A>>A>> => {
const const is: {
<K extends string>(
that: ReadonlyRecord<K, unknown>
): (self: ReadonlyRecord<K, unknown>) => boolean
<K extends string>(
self: ReadonlyRecord<K, unknown>,
that: ReadonlyRecord<K, unknown>
): boolean
}
const isSubrecordBy: <A>(
equivalence: Equivalence<A>
) => {
<K extends string>(
that: ReadonlyRecord<K, A>
): (self: ReadonlyRecord<K, A>) => boolean
<K extends string>(
self: ReadonlyRecord<K, A>,
that: ReadonlyRecord<K, A>
): boolean
}
Checks whether all the keys and values in one record are also found in another record.
Uses the provided equivalence function to compare values.
Example (Checking subrecords with a custom equivalence)
import { Equivalence, Record } from "effect"
const isSubrecord = Record.isSubrecordBy(
Equivalence.make<string>((self, that) => self.toLowerCase() === that.toLowerCase())
)
const required: Record.ReadonlyRecord<string, string> = { role: "Admin" }
const available: Record.ReadonlyRecord<string, string> = {
role: "admin",
status: "active"
}
console.log(
isSubrecord(required, available)
) // true
console.log(
isSubrecord({ role: "Admin", status: "inactive" }, available)
) // false
console.log(
isSubrecord(required, { role: "editor", status: "active" })
) // false
isSubrecordBy(equivalence: Equivalence<A>equivalence)
return (self: ReadonlyRecord<K, A>self, that: ReadonlyRecord<K, A>that) => const is: <string>(self: ReadonlyRecord<string, unknown>, that: ReadonlyRecord<string, unknown>) => boolean (+1 overload)is(self: ReadonlyRecord<K, A>self, that: ReadonlyRecord<K, A>that) && const is: <string>(self: ReadonlyRecord<string, unknown>, that: ReadonlyRecord<string, unknown>) => boolean (+1 overload)is(that: ReadonlyRecord<K, A>that, self: ReadonlyRecord<K, A>self)
}