effect 2.3.8 → 2.4.1

package/src/ReadonlyRecord.ts

@@ -17,16 +17,39 @@ import type { NoInfer } from "./Types.js"
  * @category models
  * @since 2.0.0
  */
-export interface ReadonlyRecord<out A> {
-  readonly [x: string]: A
+export type ReadonlyRecord<in out K extends string | symbol, out A> = {
+  readonly [P in K]: A
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace ReadonlyRecord {
+  type IsFiniteString<T extends string> = T extends "" ? true :
+    [T] extends [`${infer Head}${infer Rest}`]
+      ? string extends Head ? false : `${number}` extends Head ? false : Rest extends "" ? true : IsFiniteString<Rest>
+    : false
+
+  /**
+   * @since 2.0.0
+   */
+  export type NonLiteralKey<K extends string | symbol> = K extends string ? IsFiniteString<K> extends true ? string : K
+    : symbol
+
+  /**
+   * @since 2.0.0
+   */
+  export type IntersectKeys<K1 extends string, K2 extends string> = [string] extends [K1 | K2] ?
+    NonLiteralKey<K1> & NonLiteralKey<K2>
+    : K1 & K2
 }
 
 /**
  * @category type lambdas
  * @since 2.0.0
  */
-export interface ReadonlyRecordTypeLambda extends TypeLambda {
-  readonly type: ReadonlyRecord<this["Target"]>
+export interface ReadonlyRecordTypeLambda<K extends string = string> extends TypeLambda {
+  readonly type: ReadonlyRecord<K, this["Target"]>
 }
 
 /**
@@ -35,7 +58,10 @@ export interface ReadonlyRecordTypeLambda extends TypeLambda {
  * @category constructors
  * @since 2.0.0
  */
-export const empty = <A>(): Record<string, A> => ({})
+export const empty = <K extends string | symbol = never, V = never>(): Record<
+  ReadonlyRecord.NonLiteralKey<K>,
+  V
+> => ({} as any)
 
 /**
  * Determine if a record is empty.
@@ -51,14 +77,8 @@ export const empty = <A>(): Record<string, A> => ({})
  * @category guards
  * @since 2.0.0
  */
-export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string, never> => {
-  for (const k in self) {
-    if (has(self, k)) {
-      return false
-    }
-  }
-  return true
-}
+export const isEmptyRecord = <K extends string, A>(self: Record<K, A>): self is Record<K, never> =>
+  keys(self).length === 0
 
 /**
  * Determine if a record is empty.
@@ -74,7 +94,9 @@ export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string
  * @category guards
  * @since 2.0.0
  */
-export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is ReadonlyRecord<never> = isEmptyRecord
+export const isEmptyReadonlyRecord: <K extends string, A>(
+  self: ReadonlyRecord<K, A>
+) => self is ReadonlyRecord<K, never> = isEmptyRecord
 
 /**
  * Takes an iterable and a projection function and returns a record.
@@ -97,25 +119,26 @@ export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is Read
  * @since 2.0.0
  */
 export const fromIterableWith: {
-  <A, B>(f: (a: A) => readonly [string, B]): (self: Iterable<A>) => Record<string, B>
-  <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B> => {
-  const out: Record<string, B> = {}
-  for (const a of self) {
-    const [k, b] = f(a)
-    out[k] = b
+  <A, K extends string | symbol, B>(
+    f: (a: A) => readonly [K, B]
+  ): (self: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <A, K extends string | symbol, B>(
+    self: Iterable<A>,
+    f: (a: A) => readonly [K, B]
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+} = dual(
+  2,
+  <A, K extends string, B>(
+    self: Iterable<A>,
+    f: (a: A) => readonly [K, B]
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
+    const out: Record<string, B> = empty()
+    for (const a of self) {
+      const [k, b] = f(a)
+      out[k] = b
+    }
+    return out
   }
-  return out
-})
-
-/**
- * Creates a new record from an iterable collection of key/value pairs.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Record<string, V> = fromIterableWith(
-  identity
 )
 
 /**
@@ -143,8 +166,10 @@ export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Recor
  * @category constructors
  * @since 2.0.0
  */
-export const fromIterableBy = <A>(items: Iterable<A>, f: (a: A) => string): Record<string, A> =>
-  fromIterableWith(items, (a) => [f(a), a])
+export const fromIterableBy = <A, K extends string | symbol>(
+  items: Iterable<A>,
+  f: (a: A) => K
+): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
 
 /**
  * Builds a record from an iterable of key-value pairs.
@@ -161,10 +186,12 @@ export const fromIterableBy = <A>(items: Iterable<A>, f: (a: A) => string): Reco
  *
  * assert.deepStrictEqual(fromEntries(input), { a: 1, b: 2 })
  *
- * @category conversions
  * @since 2.0.0
+ * @category constructors
  */
-export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<string, A> = fromIterableWith(identity)
+export const fromEntries: <Entry extends readonly [string | symbol, any]>(
+  entries: Iterable<Entry>
+) => Record<ReadonlyRecord.NonLiteralKey<Entry[0]>, Entry[1]> = Object.fromEntries
 
 /**
  * Transforms the values of a record into an `Array` with a custom mapping function.
@@ -182,13 +209,13 @@ export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<st
  * @since 2.0.0
  */
 export const collect: {
-  <K extends string, A, B>(f: (key: K, a: A) => B): (self: Record<K, A>) => Array<B>
-  <K extends string, A, B>(self: Record<K, A>, f: (key: K, a: A) => B): Array<B>
+  <K extends string, A, B>(f: (key: K, a: A) => B): (self: ReadonlyRecord<K, A>) => Array<B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (key: K, a: A) => B): Array<B>
 } = dual(
   2,
-  <A, B>(self: ReadonlyRecord<A>, f: (key: string, a: A) => B): Array<B> => {
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (key: K, a: A) => B): Array<B> => {
     const out: Array<B> = []
-    for (const key of Object.keys(self)) {
+    for (const key of keys(self)) {
       out.push(f(key, self[key]))
     }
     return out
@@ -209,7 +236,7 @@ export const collect: {
  * @category conversions
  * @since 2.0.0
  */
-export const toEntries: <K extends string, A>(self: Record<K, A>) => Array<[K, A]> = collect((
+export const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>) => Array<[K, A]> = collect((
   key,
   value
 ) => [key, value])
@@ -226,7 +253,7 @@ export const toEntries: <K extends string, A>(self: Record<K, A>) => Array<[K, A
  *
  * @since 2.0.0
  */
-export const size = <A>(self: ReadonlyRecord<A>): number => Object.keys(self).length
+export const size = <K extends string, A>(self: ReadonlyRecord<K, A>): number => keys(self).length
 
 /**
  * Check if a given `key` exists in a record.
@@ -235,19 +262,27 @@ export const size = <A>(self: ReadonlyRecord<A>): number => Object.keys(self).le
  * @param key - the key to look for in the record.
  *
  * @example
- * import { has } from "effect/ReadonlyRecord"
+ * import { empty, has } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
- * assert.deepStrictEqual(has({ a: 1, b: 2 }, "c"), false);
+ * assert.deepStrictEqual(has(empty<string>(), "c"), false);
  *
  * @since 2.0.0
  */
 export const has: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => boolean
-  <A>(self: ReadonlyRecord<A>, key: string): boolean
+  <K extends string | symbol>(
+    key: NoInfer<K>
+  ): <A>(self: ReadonlyRecord<K, A>) => boolean
+  <K extends string | symbol, A>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>
+  ): boolean
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, key: string): boolean => Object.prototype.hasOwnProperty.call(self, key)
+  <K extends string | symbol, A>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>
+  ): boolean => Object.prototype.hasOwnProperty.call(self, key)
 )
 
 /**
@@ -260,7 +295,7 @@ export const has: {
  * import { get } from "effect/ReadonlyRecord"
  * import { some, none } from "effect/Option"
  *
- * const person = { name: "John Doe", age: 35 }
+ * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
  *
  * assert.deepStrictEqual(get(person, "name"), some("John Doe"))
  * assert.deepStrictEqual(get(person, "email"), none())
@@ -268,11 +303,12 @@ export const has: {
  * @since 2.0.0
  */
 export const get: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option.Option<A>
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A>
+  <K extends string | symbol>(key: NoInfer<K>): <A>(self: ReadonlyRecord<K, A>) => Option.Option<A>
+  <K extends string | symbol, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A> => has(self, key) ? Option.some(self[key]) : Option.none()
+  <K extends string | symbol, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A> =>
+    has(self, key) ? Option.some(self[key]) : Option.none()
 )
 
 /**
@@ -294,21 +330,21 @@ export const get: {
  *  { a: 6 }
  * )
  * assert.deepStrictEqual(
- *  modify({ a: 3 }, 'b', f),
+ *  modify({ a: 3 } as Record<string, number>, 'b', f),
  *  { a: 3 }
  * )
  *
  * @since 2.0.0
  */
 export const modify: {
-  <A, B>(
-    key: string,
+  <K extends string | symbol, A, B>(
+    key: NoInfer<K>,
     f: (a: A) => B
-  ): (self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B>
+  ): (self: ReadonlyRecord<K, A>) => Record<K, A | B>
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Record<K, A | B>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B> => {
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Record<K, A | B> => {
     if (!has(self, key)) {
       return { ...self }
     }
@@ -335,24 +371,33 @@ export const modify: {
  *  some({ a: 6 })
  * )
  * assert.deepStrictEqual(
- *  modifyOption({ a: 3 }, 'b', f),
+ *  modifyOption({ a: 3 } as Record<string, number>, 'b', f),
  *  none()
  * )
  *
  * @since 2.0.0
  */
 export const modifyOption: {
-  <A, B>(key: string, f: (a: A) => B): (self: ReadonlyRecord<A>) => Option.Option<Record<string, A | B>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option.Option<Record<string, A | B>>
+  <K extends string | symbol, A, B>(
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): (self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string | symbol, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): Option.Option<Record<K, A | B>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option.Option<Record<string, A | B>> => {
+  <K extends string | symbol, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): Option.Option<Record<K, A | B>> => {
     if (!has(self, key)) {
       return Option.none()
     }
-    const out: Record<string, A | B> = { ...self }
-    out[key] = f(self[key])
-    return Option.some(out)
+    return Option.some({ ...self, [key]: f(self[key]) })
   }
 )
 
@@ -364,28 +409,39 @@ export const modifyOption: {
  * @param b - The new value to replace the existing value with.
  *
  * @example
- * import { replaceOption } from "effect/ReadonlyRecord"
+ * import { empty, replaceOption } from "effect/ReadonlyRecord"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
  *   replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10),
  *   some({ a: 10, b: 2, c: 3 })
  * )
- * assert.deepStrictEqual(replaceOption({}, 'a', 10), none())
+ * assert.deepStrictEqual(replaceOption(empty<string>(), 'a', 10), none())
  *
  * @since 2.0.0
  */
 export const replaceOption: {
-  <B>(key: string, b: B): <A>(self: ReadonlyRecord<A>) => Option.Option<Record<string, A | B>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option.Option<Record<string, A | B>>
+  <K extends string | symbol, B>(
+    key: NoInfer<K>,
+    b: B
+  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string | symbol, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    b: B
+  ): Option.Option<Record<K, A | B>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option.Option<Record<string, A | B>> =>
-    modifyOption(self, key, () => b)
+  <K extends string | symbol, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    b: B
+  ): Option.Option<Record<K, A | B>> => modifyOption(self, key, () => b)
 )
 
 /**
- * Removes a key from a record and returns a new record
+ * If the given key exists in the record, returns a new record with the key removed,
+ * otherwise returns a copy of the original record.
  *
  * @param self - the record to remove the key from.
  * @param key - the key to remove from the record.
@@ -398,13 +454,19 @@ export const replaceOption: {
  * @since 2.0.0
  */
 export const remove: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, key: string): Record<string, A>
-} = dual(2, <A>(self: ReadonlyRecord<A>, key: string): Record<string, A> => {
-  const out = { ...self }
-  delete out[key]
-  return out
-})
+  <K extends string | symbol, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => Record<Exclude<K, X>, A>
+  <K extends string | symbol, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): Record<Exclude<K, X>, A>
+} = dual(
+  2,
+  <K extends string | symbol, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): Record<Exclude<K, X>, A> => {
+    if (!has(self, key)) {
+      return { ...self }
+    }
+    const out = { ...self }
+    delete out[key]
+    return out
+  }
+)
 
 /**
  * Retrieves the value of the property with the given `key` from a record and returns an `Option`
@@ -419,18 +481,23 @@ export const remove: {
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
- * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "c"), none())
+ * assert.deepStrictEqual(pop({ a: 1, b: 2 } as Record<string, number>, "c"), none())
  *
  * @category record
  * @since 2.0.0
  */
 export const pop: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option.Option<[A, Record<string, A>]>
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<[A, Record<string, A>]>
-} = dual(2, <A>(
-  self: ReadonlyRecord<A>,
-  key: string
-): Option.Option<[A, Record<string, A>]> =>
+  <K extends string | symbol, X extends K>(
+    key: X
+  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<[A, Record<Exclude<K, X>, A>]>
+  <K extends string | symbol, A, X extends K>(
+    self: ReadonlyRecord<K, A>,
+    key: X
+  ): Option.Option<[A, Record<Exclude<K, X>, A>]>
+} = dual(2, <K extends string | symbol, A, X extends K>(
+  self: ReadonlyRecord<K, A>,
+  key: X
+): Option.Option<[A, Record<Exclude<K, X>, A>]> =>
   has(self, key) ? Option.some([self[key], remove(self, key)]) : Option.none())
 
 /**
@@ -454,13 +521,13 @@ export const pop: {
  * @since 2.0.0
  */
 export const map: {
-  <K extends string, A, B>(f: (a: A, key: K) => B): (self: Record<K, A>) => Record<K, B>
-  <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => B): Record<K, B>
+  <K extends string, A, B>(f: (a: A, key: NoInfer<K>) => B): (self: ReadonlyRecord<K, A>) => Record<K, B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B>
 } = dual(
   2,
-  <A, B>(self: ReadonlyRecord<A>, f: (a: A, key: string) => B): Record<string, B> => {
-    const out: Record<string, B> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B> => {
+    const out: Record<K, B> = { ...self } as any
+    for (const key of keys(self)) {
       out[key] = f(self[key], key)
     }
     return out
@@ -479,13 +546,21 @@ export const map: {
  * @since 2.0.0
  */
 export const mapKeys: {
-  <A>(f: (key: string, a: A) => string): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, f: (key: string, a: A) => string): Record<string, A>
+  <K extends string, A, K2 extends string>(
+    f: (key: K, a: A) => K2
+  ): (self: ReadonlyRecord<K, A>) => Record<K2, A>
+  <K extends string, A, K2 extends string>(
+    self: ReadonlyRecord<K, A>,
+    f: (key: K, a: A) => K2
+  ): Record<K2, A>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, f: (key: string, a: A) => string): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, K2 extends string>(
+    self: ReadonlyRecord<K, A>,
+    f: (key: K, a: A) => K2
+  ): Record<K2, A> => {
+    const out: Record<K2, A> = {} as any
+    for (const key of keys(self)) {
       const a = self[key]
       out[f(key, a)] = a
     }
@@ -505,15 +580,23 @@ export const mapKeys: {
  * @since 2.0.0
  */
 export const mapEntries: {
-  <A>(f: (a: A, key: string) => [string, A]): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, f: (a: A, key: string) => [string, A]): Record<string, A>
+  <K extends string, A, K2 extends string, B>(
+    f: (a: A, key: K) => readonly [K2, B]
+  ): (self: ReadonlyRecord<K, A>) => Record<K2, B>
+  <K extends string, A, K2 extends string, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => [K2, B]
+  ): Record<K2, B>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, f: (a: A, key: string) => [string, A]): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
-      const [k, a] = f(self[key], key)
-      out[k] = a
+  <K extends string, A, K2 extends string, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => [K2, B]
+  ): Record<K2, B> => {
+    const out = <Record<K2, B>> {}
+    for (const key of keys(self)) {
+      const [k, b] = f(self[key], key)
+      out[k] = b
     }
     return out
   }
@@ -537,21 +620,29 @@ export const mapEntries: {
  * @since 2.0.0
  */
 export const filterMap: {
-  <K extends string, A, B>(f: (a: A, key: K) => Option.Option<B>): (self: Record<K, A>) => Record<string, B>
-  <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<string, B>
-} = dual(2, <A, B>(
-  self: Record<string, A>,
-  f: (a: A, key: string) => Option.Option<B>
-): Record<string, B> => {
-  const out: Record<string, B> = {}
-  for (const key of Object.keys(self)) {
-    const o = f(self[key], key)
-    if (Option.isSome(o)) {
-      out[key] = o.value
+  <K extends string, A, B>(
+    f: (a: A, key: K) => Option.Option<B>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Option.Option<B>
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+} = dual(
+  2,
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Option.Option<B>
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
+    const out: Record<string, B> = empty()
+    for (const key of keys(self)) {
+      const o = f(self[key], key)
+      if (Option.isSome(o)) {
+        out[key] = o.value
+      }
     }
+    return out
   }
-  return out
-})
+)
 
 /**
  * Selects properties from a record whose values match the given predicate.
@@ -571,20 +662,26 @@ export const filterMap: {
 export const filter: {
   <K extends string, A, B extends A>(
     refinement: (a: NoInfer<A>, key: K) => a is B
-  ): (self: Record<K, A>) => Record<string, B>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   <K extends string, A>(
     predicate: (A: NoInfer<A>, key: K) => boolean
-  ): (self: Record<K, A>) => Record<string, A>
-  <K extends string, A, B extends A>(self: Record<K, A>, refinement: (a: A, key: K) => a is B): Record<string, B>
-  <K extends string, A>(self: Record<K, A>, predicate: (a: A, key: K) => boolean): Record<string, A>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  <K extends string, A, B extends A>(
+    self: ReadonlyRecord<K, A>,
+    refinement: (a: A, key: K) => a is B
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A>
 } = dual(
   2,
-  <A>(
-    self: Record<string, A>,
-    predicate: (a: A, key: string) => boolean
-  ): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A> => {
+    const out: Record<string, A> = empty()
+    for (const key of keys(self)) {
       if (predicate(self[key], key)) {
         out[key] = self[key]
       }
@@ -610,7 +707,9 @@ export const filter: {
  * @category filtering
  * @since 2.0.0
  */
-export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
+export const getSomes: <K extends string, A>(
+  self: ReadonlyRecord<K, Option.Option<A>>
+) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = filterMap(
   identity
 )
 
@@ -629,9 +728,11 @@ export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<str
  * @category filtering
  * @since 2.0.0
  */
-export const getLefts = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, E> => {
-  const out: Record<string, E> = {}
-  for (const key of Object.keys(self)) {
+export const getLefts = <K extends string, R, L>(
+  self: ReadonlyRecord<K, Either<R, L>>
+): Record<ReadonlyRecord.NonLiteralKey<K>, L> => {
+  const out: Record<string, L> = empty()
+  for (const key of keys(self)) {
     const value = self[key]
     if (E.isLeft(value)) {
       out[key] = value.left
@@ -656,9 +757,11 @@ export const getLefts = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<strin
  * @category filtering
  * @since 2.0.0
  */
-export const getRights = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, A> => {
-  const out: Record<string, A> = {}
-  for (const key of Object.keys(self)) {
+export const getRights = <K extends string, R, L>(
+  self: ReadonlyRecord<K, Either<R, L>>
+): Record<string, R> => {
+  const out: Record<string, R> = empty()
+  for (const key of keys(self)) {
     const value = self[key]
     if (E.isRight(value)) {
       out[key] = value.right
@@ -687,21 +790,23 @@ export const getRights = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<stri
  */
 export const partitionMap: {
   <K extends string, A, B, C>(
-    f: (a: A, key: K) => Either<B, C>
-  ): (self: Record<K, A>) => [left: Record<string, B>, right: Record<string, C>]
+    f: (a: A, key: K) => Either<C, B>
+  ): (
+    self: ReadonlyRecord<K, A>
+  ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   <K extends string, A, B, C>(
-    self: Record<K, A>,
-    f: (a: A, key: K) => Either<B, C>
-  ): [left: Record<string, B>, right: Record<string, C>]
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Either<C, B>
+  ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
-  <A, B, C>(
-    self: Record<string, A>,
-    f: (a: A, key: string) => Either<B, C>
-  ): [left: Record<string, B>, right: Record<string, C>] => {
-    const left: Record<string, B> = {}
-    const right: Record<string, C> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, B, C>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Either<C, B>
+  ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>] => {
+    const left: Record<string, B> = empty()
+    const right: Record<string, C> = empty()
+    for (const key of keys(self)) {
       const e = f(self[key], key)
       if (E.isLeft(e)) {
         left[key] = e.left
@@ -731,9 +836,9 @@ export const partitionMap: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate: <A, B>(
-  self: ReadonlyRecord<Either<A, B>>
-) => [Record<string, A>, Record<string, B>] = partitionMap(identity)
+export const separate: <K extends string, A, B>(
+  self: ReadonlyRecord<K, Either<B, A>>
+) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partitionMap(identity)
 
 /**
  * Partitions a record into two separate records based on the result of a predicate function.
@@ -754,28 +859,36 @@ export const separate: <A, B>(
  */
 export const partition: {
   <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
-    self: Record<K, A>
-  ) => [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+    self: ReadonlyRecord<K, A>
+  ) => [
+    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
+    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  ]
   <K extends string, A>(
     predicate: (a: NoInfer<A>, key: K) => boolean
-  ): (self: Record<K, A>) => [excluded: Record<string, A>, satisfying: Record<string, A>]
+  ): (
+    self: ReadonlyRecord<K, A>
+  ) => [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
   <K extends string, A, B extends A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     refinement: (a: A, key: K) => a is B
-  ): [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+  ): [
+    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
+    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  ]
   <K extends string, A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     predicate: (a: A, key: K) => boolean
-  ): [excluded: Record<string, A>, satisfying: Record<string, A>]
+  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
 } = dual(
   2,
-  <A>(
-    self: Record<string, A>,
-    predicate: (a: A, key: string) => boolean
-  ): [excluded: Record<string, A>, satisfying: Record<string, A>] => {
-    const left: Record<string, A> = {}
-    const right: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>] => {
+    const left: Record<string, A> = empty()
+    const right: Record<string, A> = empty()
+    for (const key of keys(self)) {
       if (predicate(self[key], key)) {
         right[key] = self[key]
       } else {
@@ -793,7 +906,7 @@ export const partition: {
  *
  * @since 2.0.0
  */
-export const keys = <A>(self: ReadonlyRecord<A>): Array<string> => Object.keys(self)
+export const keys = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<K> => Object.keys(self) as Array<K>
 
 /**
  * Retrieve the values of a given record as an array.
@@ -802,7 +915,7 @@ export const keys = <A>(self: ReadonlyRecord<A>): Array<string> => Object.keys(s
  *
  * @since 2.0.0
  */
-export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_, a) => a)
+export const values = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<A> => collect(self, (_, a) => a)
 
 /**
  * Add a new key-value pair or update an existing key's value in a record.
@@ -820,16 +933,29 @@ export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_
  * @since 2.0.0
  */
 export const set: {
-  <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
-} = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {
-  const out: Record<string, A | B> = { ...self }
-  out[key] = value
-  return out
-})
+  <K extends string | symbol, K1 extends K | ((string | symbol) & {}), B>(
+    key: K1,
+    value: B
+  ): <A>(self: ReadonlyRecord<K, A>) => Record<K | K1, A | B>
+  <K extends string | symbol, A, K1 extends K | ((string | symbol) & {}), B>(
+    self: ReadonlyRecord<K, A>,
+    key: K1,
+    value: B
+  ): Record<K | K1, A | B>
+} = dual(
+  3,
+  <K extends string | symbol, A, K1 extends K | ((string | symbol) & {}), B>(
+    self: ReadonlyRecord<K, A>,
+    key: K1,
+    value: B
+  ): Record<K | K1, A | B> => {
+    return { ...self, [key]: value } as any
+  }
+)
 
 /**
  * Replace a key's value in a record and return the updated record.
+ * If the key does not exist in the record, a copy of the original record is returned.
  *
  * @param self - The original record.
  * @param key - The key to replace.
@@ -845,15 +971,17 @@ export const set: {
  * @since 2.0.0
  */
 export const replace: {
-  <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
-} = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {
-  const out: Record<string, A | B> = { ...self }
-  if (has(self, key)) {
-    out[key] = value
+  <K extends string | symbol, B>(key: NoInfer<K>, value: B): <A>(self: ReadonlyRecord<K, A>) => Record<K, A | B>
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, value: B): Record<K, A | B>
+} = dual(
+  3,
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, value: B): Record<K, A | B> => {
+    if (has(self, key)) {
+      return { ...self, [key]: value }
+    }
+    return { ...self }
   }
-  return out
-})
+)
 
 /**
  * Check if all the keys and values in one record are also found in another record.
@@ -865,11 +993,11 @@ export const replace: {
  * @since 2.0.0
  */
 export const isSubrecordBy = <A>(equivalence: Equivalence<A>): {
-  (that: ReadonlyRecord<A>): (self: ReadonlyRecord<A>) => boolean
-  (self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean
+  <K extends string>(that: ReadonlyRecord<K, A>): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean
 } =>
-  dual(2, (self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean => {
-    for (const key in self) {
+  dual(2, <K extends string>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean => {
+    for (const key of keys(self)) {
       if (!has(that, key) || !equivalence(self[key], that[key])) {
         return false
       }
@@ -887,8 +1015,8 @@ export const isSubrecordBy = <A>(equivalence: Equivalence<A>): {
  * @since 2.0.0
  */
 export const isSubrecord: {
-  <A>(that: ReadonlyRecord<A>): (self: ReadonlyRecord<A>) => boolean
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean
+  <K extends string, A>(that: ReadonlyRecord<K, A>): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string, A>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean
 } = isSubrecordBy(Equal.equivalence())
 
 /**
@@ -902,15 +1030,25 @@ export const isSubrecord: {
  * @since 2.0.0
  */
 export const reduce: {
-  <Z, V, K extends string>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: Record<K, V>) => Z
-  <K extends string, V, Z>(self: Record<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
-} = dual(3, <V, Z>(self: Record<string, V>, zero: Z, f: (accumulator: Z, value: V, key: string) => Z): Z => {
-  let out: Z = zero
-  for (const key in self) {
-    out = f(out, self[key], key)
+  <Z, V, K extends string>(
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ): (self: ReadonlyRecord<K, V>) => Z
+  <K extends string, V, Z>(self: ReadonlyRecord<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+} = dual(
+  3,
+  <K extends string, V, Z>(
+    self: ReadonlyRecord<K, V>,
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ): Z => {
+    let out: Z = zero
+    for (const key of keys(self)) {
+      out = f(out, self[key], key)
+    }
+    return out
   }
-  return out
-})
+)
 
 /**
  * Check if all entries in a record meet a specific condition.
@@ -923,24 +1061,27 @@ export const reduce: {
 export const every: {
   <A, K extends string, B extends A>(
     refinement: (value: A, key: K) => value is B
-  ): (self: Record<K, A>) => self is Readonly<Record<K, B>>
-  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
+  ): (self: ReadonlyRecord<K, A>) => self is ReadonlyRecord<K, B>
+  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord<K, A>) => boolean
+  <A, K extends string, B extends A>(
+    self: ReadonlyRecord<K, A>,
+    refinement: (value: A, key: K) => value is B
+  ): self is ReadonlyRecord<K, B>
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean
+} = dual(
+  2,
   <A, K extends string, B extends A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     refinement: (value: A, key: K) => value is B
-  ): self is Readonly<Record<K, B>>
-  <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <A, K extends string, B extends A>(
-  self: Record<K, A>,
-  refinement: (value: A, key: K) => value is B
-): self is Readonly<Record<K, A>> => {
-  for (const key in self) {
-    if (!refinement(self[key], key)) {
-      return false
+  ): self is ReadonlyRecord<K, B> => {
+    for (const key of keys(self)) {
+      if (!refinement(self[key], key)) {
+        return false
+      }
     }
+    return true
   }
-  return true
-})
+)
 
 /**
  * Check if any entry in a record meets a specific condition.
@@ -951,16 +1092,19 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
-  <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
-  for (const key in self) {
-    if (predicate(self[key], key)) {
-      return true
+  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean
+} = dual(
+  2,
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
+    for (const key of keys(self)) {
+      if (predicate(self[key], key)) {
+        return true
+      }
     }
+    return false
   }
-  return false
-})
+)
 
 /**
  * Merge two records, preserving entries that exist in either of the records.
@@ -972,37 +1116,37 @@ export const some: {
  * @since 2.0.0
  */
 export const union: {
-  <K1 extends string, V0, V1>(
-    that: Record<K1, V1>,
-    combine: (selfValue: V0, thatValue: V1) => V0 | V1
-  ): <K0 extends string>(self: Record<K0, V0>) => Record<K0 | K1, V0 | V1>
-  <K0 extends string, V0, K1 extends string, V1>(
-    self: Record<K0, V0>,
-    that: Record<K1, V1>,
-    combine: (selfValue: V0, thatValue: V1) => V0 | V1
-  ): Record<K0 | K1, V0 | V1>
+  <K1 extends string, A, B, C>(
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B | C>
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<K0 | K1, A | B | C>
 } = dual(
   3,
-  <A>(
-    self: Record<string, A>,
-    that: Record<string, A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): Record<string, A> => {
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<K0 | K1, A | B | C> => {
     if (isEmptyRecord(self)) {
-      return { ...that }
+      return { ...that } as any
     }
     if (isEmptyRecord(that)) {
-      return { ...self }
+      return { ...self } as any
     }
-    const out: Record<string, A> = {}
-    for (const key in self) {
-      if (has(that, key)) {
-        out[key] = combine(self[key], that[key])
+    const out: Record<string, A | B | C> = empty()
+    for (const key of keys(self)) {
+      if (has(that, key as any)) {
+        out[key] = combine(self[key], that[key as unknown as K1])
       } else {
         out[key] = self[key]
       }
     }
-    for (const key in that) {
+    for (const key of keys(that)) {
       if (!has(out, key)) {
         out[key] = that[key]
       }
@@ -1021,25 +1165,29 @@ export const union: {
  * @since 2.0.0
  */
 export const intersection: {
-  <A>(
-    that: ReadonlyRecord<A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>, combine: (selfValue: A, thatValue: A) => A): Record<string, A>
+  <K1 extends string, A, B, C>(
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
 } = dual(
   3,
-  <A>(
-    self: ReadonlyRecord<A>,
-    that: ReadonlyRecord<A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): Record<string, A> => {
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<ReadonlyRecord.IntersectKeys<K0, K1>, C> => {
+    const out: Record<string, C> = empty()
     if (isEmptyRecord(self) || isEmptyRecord(that)) {
-      return empty()
+      return out
     }
-    const out: Record<string, A> = {}
-    for (const key in self) {
-      if (has(that, key)) {
-        out[key] = combine(self[key], that[key])
+    for (const key of keys(self)) {
+      if (has(that, key as any)) {
+        out[key] = combine(self[key], that[key as unknown as K1])
       }
     }
     return out
@@ -1055,25 +1203,31 @@ export const intersection: {
  * @since 2.0.0
  */
 export const difference: {
-  <A>(
-    that: ReadonlyRecord<A>
-  ): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): Record<string, A>
-} = dual(2, <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): Record<string, A> => {
+  <K1 extends string, B>(
+    that: ReadonlyRecord<K1, B>
+  ): <K0 extends string, A>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B>
+  <K0 extends string, A, K1 extends string, B>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>
+  ): Record<K0 | K1, A | B>
+} = dual(2, <K0 extends string, A, K1 extends string, B>(
+  self: ReadonlyRecord<K0, A>,
+  that: ReadonlyRecord<K1, B>
+): Record<K0 | K1, A | B> => {
   if (isEmptyRecord(self)) {
-    return { ...that }
+    return { ...that } as any
   }
   if (isEmptyRecord(that)) {
-    return { ...self }
+    return { ...self } as any
   }
-  const out: Record<string, A> = {}
-  for (const key in self) {
-    if (!has(that, key)) {
+  const out = <Record<K0 | K1, A | B>> {}
+  for (const key of keys(self)) {
+    if (!has(that, key as any)) {
       out[key] = self[key]
     }
   }
-  for (const key in that) {
-    if (!has(self, key)) {
+  for (const key of keys(that)) {
+    if (!has(self, key as any)) {
       out[key] = that[key]
     }
   }
@@ -1088,7 +1242,9 @@ export const difference: {
  * @category instances
  * @since 2.0.0
  */
-export const getEquivalence = <A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<A>> => {
+export const getEquivalence = <K extends string, A>(
+  equivalence: Equivalence<A>
+): Equivalence<ReadonlyRecord<K, A>> => {
   const is = isSubrecordBy(equivalence)
   return (self, that) => is(self, that) && is(that, self)
 }
@@ -1102,6 +1258,6 @@ export const getEquivalence = <A>(equivalence: Equivalence<A>): Equivalence<Read
  * @category constructors
  * @since 2.0.0
  */
-export const singleton = <K extends string, A>(key: K, value: A): Record<K, A> => (({
+export const singleton = <K extends string | symbol, A>(key: K, value: A): Record<K, A> => ({
   [key]: value
-}) as Record<K, A>)
+} as any)