effect 2.0.0-next.49 → 2.0.0-next.50

package/src/ReadonlyRecord.ts

@@ -6,14 +6,11 @@
 
 import type { Either } from "./Either"
 import * as E from "./Either"
+import * as Equal from "./Equal"
+import type { Equivalence } from "./Equivalence"
 import { dual, identity } from "./Function"
 import type { TypeLambda } from "./HKT"
-import type { Option } from "./Option"
-import * as O from "./Option"
-
-// -------------------------------------------------------------------------------------
-// models
-// -------------------------------------------------------------------------------------
+import * as Option from "./Option"
 
 /**
  * @category models
@@ -31,10 +28,6 @@ export interface ReadonlyRecordTypeLambda extends TypeLambda {
   readonly type: ReadonlyRecord<this["Target"]>
 }
 
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-
 /**
  * Creates a new, empty record.
  *
@@ -43,14 +36,10 @@ export interface ReadonlyRecordTypeLambda extends TypeLambda {
  */
 export const empty = <A>(): Record<string, A> => ({})
 
-// -------------------------------------------------------------------------------------
-// guards
-// -------------------------------------------------------------------------------------
-
 /**
- * Determine if a `Record` is empty.
+ * Determine if a record is empty.
  *
- * @param self - `Record` to test for emptiness.
+ * @param self - record to test for emptiness.
  *
  * @example
  * import { isEmptyRecord } from "effect/ReadonlyRecord"
@@ -71,9 +60,9 @@ export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string
 }
 
 /**
- * Determine if a `ReadonlyRecord` is empty.
+ * Determine if a record is empty.
  *
- * @param self - `ReadonlyRecord` to test for emptiness.
+ * @param self - record to test for emptiness.
  *
  * @example
  * import { isEmptyReadonlyRecord } from "effect/ReadonlyRecord"
@@ -86,10 +75,6 @@ export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string
  */
 export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is ReadonlyRecord<never> = isEmptyRecord
 
-// -------------------------------------------------------------------------------------
-// conversions
-// -------------------------------------------------------------------------------------
-
 /**
  * Takes an iterable and a projection function and returns a record.
  * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record.
@@ -98,7 +83,7 @@ export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is Read
  * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
  *
  * @example
- * import { fromIterable } from 'effect/ReadonlyRecord'
+ * import { fromIterable } from "effect/ReadonlyRecord"
  *
  * const input = [1, 2, 3, 4]
  *
@@ -131,7 +116,7 @@ export const fromIterable: {
  * @param self - The iterable of key-value pairs.
  *
  * @example
- * import { fromEntries } from 'effect/ReadonlyRecord'
+ * import { fromEntries } from "effect/ReadonlyRecord"
  *
  * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
  *
@@ -143,10 +128,10 @@ export const fromIterable: {
 export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<string, A> = fromIterable(identity)
 
 /**
- * Transforms the values of a `ReadonlyRecord` into an `Array` with a custom mapping function.
+ * Transforms the values of a record into an `Array` with a custom mapping function.
  *
- * @param self - The `ReadonlyRecord` to transform.
- * @param f - The custom mapping function to apply to each key/value of the `ReadonlyRecord`.
+ * @param self - The record to transform.
+ * @param f - The custom mapping function to apply to each key/value of the record.
  *
  * @example
  * import { collect } from "effect/ReadonlyRecord"
@@ -191,31 +176,9 @@ export const toEntries: <K extends string, A>(self: Record<K, A>) => Array<[K, A
 ) => [key, value])
 
 /**
- * Takes a record and returns an array of tuples containing its keys and values.
+ * Returns the number of key/value pairs in a record.
  *
- * Alias of {@link toEntries}.
- *
- * @param self - The record to transform.
- *
- * @example
- * import { toArray } from "effect/ReadonlyRecord"
- *
- * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(toArray(x), [["a", 1], ["b", 2], ["c", 3]])
- *
- * @category conversions
- * @since 2.0.0
- */
-export const toArray: <K extends string, A>(self: Record<K, A>) => Array<[K, A]> = toEntries
-
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns the number of key/value pairs in a `ReadonlyRecord`.
- *
- * @param self - A `ReadonlyRecord` to calculate the number of key/value pairs in.
+ * @param self - A record to calculate the number of key/value pairs in.
  *
  * @example
  * import { size } from "effect/ReadonlyRecord";
@@ -227,13 +190,13 @@ export const toArray: <K extends string, A>(self: Record<K, A>) => Array<[K, A]>
 export const size = <A>(self: ReadonlyRecord<A>): number => Object.keys(self).length
 
 /**
- * Check if a given `key` exists in a `ReadonlyRecord`.
+ * Check if a given `key` exists in a record.
  *
- * @param self - the `ReadonlyRecord` to look in.
- * @param key - the key to look for in the `ReadonlyRecord`.
+ * @param self - the record to look in.
+ * @param key - the key to look for in the record.
  *
  * @example
- * import { has } from 'effect/ReadonlyRecord'
+ * import { has } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "c"), false);
@@ -249,10 +212,10 @@ export const has: {
 )
 
 /**
- * Retrieve a value at a particular key from a `ReadonlyRecord`, returning it wrapped in an `Option`.
+ * Retrieve a value at a particular key from a record, returning it wrapped in an `Option`.
  *
- * @param self - The `ReadonlyRecord` to retrieve value from.
- * @param key - Key to retrieve from `ReadonlyRecord`.
+ * @param self - The record to retrieve value from.
+ * @param key - Key to retrieve from record.
  *
  * @example
  * import { get } from "effect/ReadonlyRecord"
@@ -266,18 +229,18 @@ export const has: {
  * @since 2.0.0
  */
 export const get: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option<A>
-  <A>(self: ReadonlyRecord<A>, key: string): Option<A>
+  (key: string): <A>(self: ReadonlyRecord<A>) => Option.Option<A>
+  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, key: string): Option<A> => has(self, key) ? O.some(self[key]) : O.none()
+  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A> => has(self, key) ? Option.some(self[key]) : Option.none()
 )
 
 /**
  * Apply a function to the element at the specified key, creating a new record,
  * or return `None` if the key doesn't exist.
  *
- * @param self - The `ReadonlyRecord` to be updated.
+ * @param self - The record to be updated.
  * @param key - The key of the element to modify.
  * @param f - The function to apply to the element.
  *
@@ -299,24 +262,24 @@ export const get: {
  * @since 2.0.0
  */
 export const modifyOption: {
-  <A, B>(key: string, f: (a: A) => B): (self: ReadonlyRecord<A>) => Option<Record<string, A | B>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option<Record<string, A | B>>
+  <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>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option<Record<string, A | B>> => {
+  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option.Option<Record<string, A | B>> => {
     if (!has(self, key)) {
-      return O.none()
+      return Option.none()
     }
     const out: Record<string, A | B> = { ...self }
     out[key] = f(self[key])
-    return O.some(out)
+    return Option.some(out)
   }
 )
 
 /**
  * Replaces a value in the record with the new value passed as parameter.
  *
- * @param self - The `ReadonlyRecord` to be updated.
+ * @param self - The record to be updated.
  * @param key - The key to search for in the record.
  * @param b - The new value to replace the existing value with.
  *
@@ -333,21 +296,22 @@ export const modifyOption: {
  * @since 2.0.0
  */
 export const replaceOption: {
-  <B>(key: string, b: B): <A>(self: ReadonlyRecord<A>) => Option<Record<string, B | A>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option<Record<string, A | B>>
+  <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>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option<Record<string, A | B>> => modifyOption(self, key, () => b)
+  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option.Option<Record<string, A | B>> =>
+    modifyOption(self, key, () => b)
 )
 
 /**
- * Removes a key from a `ReadonlyRecord` and returns a new `Record`
+ * Removes a key from a record and returns a new record
  *
- * @param self - the `ReadonlyRecord` to remove the key from.
- * @param key - the key to remove from the `ReadonlyRecord`.
+ * @param self - the record to remove the key from.
+ * @param key - the key to remove from the record.
  *
  * @example
- * import { remove } from 'effect/ReadonlyRecord'
+ * import { remove } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 })
  *
@@ -357,21 +321,21 @@ 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: Record<string, A> = { ...self }
+  const out = { ...self }
   delete out[key]
   return out
 })
 
 /**
- * Retrieves the value of the property with the given `key` from a `ReadonlyRecord` and returns an `Option`
- * of a tuple with the value and the `ReadonlyRecord` with the removed property.
+ * Retrieves the value of the property with the given `key` from a record and returns an `Option`
+ * of a tuple with the value and the record with the removed property.
  * If the key is not present, returns `O.none`.
  *
- * @param self - The input `ReadonlyRecord`.
+ * @param self - The input record.
  * @param key - The key of the property to retrieve.
  *
  * @example
- * import { pop } from 'effect/ReadonlyRecord'
+ * import { pop } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
@@ -381,18 +345,19 @@ export const remove: {
  * @since 2.0.0
  */
 export const pop: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option<readonly [A, ReadonlyRecord<A>]>
-  <A>(self: ReadonlyRecord<A>, key: string): Option<readonly [A, ReadonlyRecord<A>]>
+  (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<readonly [A, ReadonlyRecord<A>]> => has(self, key) ? O.some([self[key], remove(self, key)]) : O.none())
+): Option.Option<[A, Record<string, A>]> =>
+  has(self, key) ? Option.some([self[key], remove(self, key)]) : Option.none())
 
 /**
- * Maps a `ReadonlyRecord` into another `Record` by applying a transformation function to each of its values.
+ * Maps a record into another record by applying a transformation function to each of its values.
  *
- * @param self - The `ReadonlyRecord` to be mapped.
- * @param f - A transformation function that will be applied to each of the values in the `ReadonlyRecord`.
+ * @param self - The record to be mapped.
+ * @param f - A transformation function that will be applied to each of the values in the record.
  *
  * @example
  * import { map } from "effect/ReadonlyRecord"
@@ -422,14 +387,14 @@ export const map: {
 )
 
 /**
- * Transforms a `ReadonlyRecord` into a `Record` by applying the function `f` to each key and value in the original `ReadonlyRecord`.
- * If the function returns `Some`, the key-value pair is included in the output `Record`.
+ * Transforms a record into a record by applying the function `f` to each key and value in the original record.
+ * If the function returns `Some`, the key-value pair is included in the output record.
  *
- * @param self - The input `ReadonlyRecord`.
+ * @param self - The input record.
  * @param f - The transformation function.
  *
  * @example
- * import { filterMap } from 'effect/ReadonlyRecord'
+ * import { filterMap } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -439,16 +404,16 @@ export const map: {
  * @since 2.0.0
  */
 export const filterMap: {
-  <K extends string, A, B>(f: (a: A, key: K) => Option<B>): (self: Record<K, A>) => Record<string, B>
-  <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => Option<B>): Record<string, B>
+  <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<B>
+  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 (O.isSome(o)) {
+    if (Option.isSome(o)) {
       out[key] = o.value
     }
   }
@@ -458,11 +423,11 @@ export const filterMap: {
 /**
  * Selects properties from a record whose values match the given predicate.
  *
- * @param self - The `ReadonlyRecord` to filter.
+ * @param self - The record to filter.
  * @param predicate - A function that returns a `boolean` value to determine if the entry should be included in the new record.
  *
  * @example
- * import { filter } from 'effect/ReadonlyRecord'
+ * import { filter } from "effect/ReadonlyRecord"
  *
  * const x = { a: 1, b: 2, c: 3, d: 4 }
  * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 })
@@ -502,12 +467,12 @@ export const filter: {
 )
 
 /**
- * Given a `ReadonlyRecord` with `Option` values, returns a `Record` with only the `Some` values, with the same keys.
+ * Given a record with `Option` values, returns a record with only the `Some` values, with the same keys.
  *
- * @param self - A `ReadonlyRecord` with `Option` values.
+ * @param self - A record with `Option` values.
  *
  * @example
- * import { compact } from 'effect/ReadonlyRecord'
+ * import { compact } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(
@@ -518,18 +483,18 @@ export const filter: {
  * @category filtering
  * @since 2.0.0
  */
-export const compact: <A>(self: ReadonlyRecord<Option<A>>) => Record<string, A> = filterMap(
+export const compact: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
   identity
 )
 
 /**
- * Partitions the elements of a `ReadonlyRecord` into two groups: those that match a predicate, and those that don't.
+ * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
  *
- * @param self - The `ReadonlyRecord` to partition.
+ * @param self - The record to partition.
  * @param f - The predicate function to apply to each element.
  *
  * @example
- * import { partitionMap } from 'effect/ReadonlyRecord'
+ * import { partitionMap } from "effect/ReadonlyRecord"
  * import { left, right } from 'effect/Either'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -568,13 +533,13 @@ export const partitionMap: {
 )
 
 /**
- * Partitions a `ReadonlyRecord` of `Either` values into two separate records,
+ * Partitions a record of `Either` values into two separate records,
  * one with the `Left` values and one with the `Right` values.
  *
- * @param self - the `ReadonlyRecord` to partition.
+ * @param self - the record to partition.
  *
  * @example
- * import { separate } from 'effect/ReadonlyRecord'
+ * import { separate } from "effect/ReadonlyRecord"
  * import { left, right } from 'effect/Either'
  *
  * assert.deepStrictEqual(
@@ -590,13 +555,13 @@ export const separate: <A, B>(
 ) => [Record<string, A>, Record<string, B>] = partitionMap(identity)
 
 /**
- * Partitions a `ReadonlyRecord` into two separate `Record`s based on the result of a predicate function.
+ * Partitions a record into two separate records based on the result of a predicate function.
  *
- * @param self - The input `ReadonlyRecord` to partition.
- * @param predicate - The partitioning function to determine the partitioning of each value of the `ReadonlyRecord`.
+ * @param self - The input record to partition.
+ * @param predicate - The partitioning function to determine the partitioning of each value of the record.
  *
  * @example
- * import { partition } from 'effect/ReadonlyRecord'
+ * import { partition } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(
  *   partition({ a: 1, b: 3 }, (n) => n > 2),
@@ -639,3 +604,311 @@ export const partition: {
     return [left, right]
   }
 )
+
+/**
+ * Retrieve the keys of a given record as an array.
+ *
+ * @param self - The object for which you want to get the keys.
+ *
+ * @since 2.0.0
+ */
+export const keys = <A>(self: ReadonlyRecord<A>): Array<string> => Object.keys(self)
+
+/**
+ * Retrieve the values of a given record as an array.
+ *
+ * @param self - The object for which you want to get the values.
+ *
+ * @since 2.0.0
+ */
+export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_, a) => a)
+
+/**
+ * Add a new key-value pair or update an existing key's value in a record.
+ *
+ * @param self - The record to which you want to add or update a key-value pair.
+ * @param key - The key you want to add or update.
+ * @param values - The value you want to associate with the key.
+ *
+ * @example
+ * import { upsert } from "effect/ReadonlyRecord"
+ *
+ * assert.deepStrictEqual(upsert("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
+ * assert.deepStrictEqual(upsert("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
+ *
+ * @since 2.0.0
+ */
+export const upsert: {
+  <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
+})
+
+/**
+ * Replace a key's value in a record and return the updated record.
+ *
+ * @param self - The original record.
+ * @param key - The key to replace.
+ * @param value - The new value to associate with the key.
+ *
+ * @example
+ * import { update } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(update("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
+ * assert.deepStrictEqual(update("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
+ *
+ * @since 2.0.0
+ */
+export const update: {
+  <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
+  }
+  return out
+})
+
+/**
+ * Check if all the keys and values in one record are also found in another record.
+ *
+ * @param self - The first record to check.
+ * @param that - The second record to compare against.
+ * @param equivalence - A function to compare values.
+ *
+ * @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
+} =>
+  dual(2, (self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean => {
+    for (const key in self) {
+      if (!has(that, key) || !equivalence(self[key], that[key])) {
+        return false
+      }
+    }
+    return true
+  })
+
+/**
+ * Check if one record is a subrecord of another, meaning it contains all the keys and values found in the second record.
+ * This comparison uses default equality checks (`Equal.equivalence()`).
+ *
+ * @param self - The first record to check.
+ * @param that - The second record to compare against.
+ *
+ * @since 2.0.0
+ */
+export const isSubrecord: {
+  <A>(that: ReadonlyRecord<A>): (self: ReadonlyRecord<A>) => boolean
+  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean
+} = isSubrecordBy(Equal.equivalence())
+
+/**
+ * Reduce a record to a single value by combining its entries with a specified function.
+ *
+ * @param self - The record to reduce.
+ * @param zero - The initial value of the accumulator.
+ * @param f - The function to combine entries (accumulator, value, key).
+ *
+ * @category folding
+ * @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)
+  }
+  return out
+})
+
+/**
+ * Check if all entries in a record meet a specific condition.
+ *
+ * @param self - The record to check.
+ * @param predicate - The condition to test entries (value, key).
+ *
+ * @since 2.0.0
+ */
+export const every: {
+  <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 false
+    }
+  }
+  return true
+})
+
+/**
+ * Check if any entry in a record meets a specific condition.
+ *
+ * @param self - The record to check.
+ * @param predicate - The condition to test entries (value, key).
+ *
+ * @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
+    }
+  }
+  return false
+})
+
+/**
+ * Merge two records, preserving entries that exist in either of the records.
+ *
+ * @param self - The first record.
+ * @param that - The second record to combine with the first.
+ * @param combine - A function to specify how to merge entries with the same key.
+ *
+ * @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>
+} = dual(
+  3,
+  <A>(
+    self: Record<string, A>,
+    that: Record<string, A>,
+    combine: (selfValue: A, thatValue: A) => A
+  ): Record<string, A> => {
+    if (isEmptyRecord(self)) {
+      return { ...that }
+    }
+    if (isEmptyRecord(that)) {
+      return { ...self }
+    }
+    const out: Record<string, A> = {}
+    for (const key in self) {
+      if (has(that, key)) {
+        out[key] = combine(self[key], that[key])
+      } else {
+        out[key] = self[key]
+      }
+    }
+    for (const key in that) {
+      if (!has(out, key)) {
+        out[key] = that[key]
+      }
+    }
+    return out
+  }
+)
+
+/**
+ * Merge two records, retaining only the entries that exist in both records.
+ *
+ * @param self - The first record.
+ * @param that - The second record to merge with the first.
+ * @param combine - A function to specify how to merge entries with the same key.
+ *
+ * @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>
+} = dual(
+  3,
+  <A>(
+    self: ReadonlyRecord<A>,
+    that: ReadonlyRecord<A>,
+    combine: (selfValue: A, thatValue: A) => A
+  ): Record<string, A> => {
+    if (isEmptyRecord(self) || isEmptyRecord(that)) {
+      return empty()
+    }
+    const out: Record<string, A> = {}
+    for (const key in self) {
+      if (has(that, key)) {
+        out[key] = combine(self[key], that[key])
+      }
+    }
+    return out
+  }
+)
+
+/**
+ * Merge two records, preserving only the entries that are unique to each record.
+ *
+ * @param self - The first record.
+ * @param that - The second record to compare with the first.
+ *
+ * @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> => {
+  if (isEmptyRecord(self)) {
+    return { ...that }
+  }
+  if (isEmptyRecord(that)) {
+    return { ...self }
+  }
+  const out: Record<string, A> = {}
+  for (const key in self) {
+    if (!has(that, key)) {
+      out[key] = self[key]
+    }
+  }
+  for (const key in that) {
+    if (!has(self, key)) {
+      out[key] = that[key]
+    }
+  }
+  return out
+})
+
+/**
+ * Create an `Equivalence` for records using the provided `Equivalence` for values.
+ *
+ * @param equivalence - An `Equivalence` for the values contained in the records.
+ *
+ * @category instances
+ * @since 2.0.0
+ */
+export const getEquivalence = <A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<A>> => {
+  const is = isSubrecordBy(equivalence)
+  return (self, that) => is(self, that) && is(that, self)
+}
+
+/**
+ * Create a non-empty record from a single element.
+ *
+ * @param key - The key for the element.
+ * @param value - The value associated with the key.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export const singleton = <K extends string, A>(key: K, value: A): Record<K, A> => ({ [key]: value }) as Record<K, A>