effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/Record.ts

@@ -543,7 +543,7 @@ export const get: {
 
 /**
  * Apply a function to the element at the specified key, creating a new record,
- * or return `undefined` if the key doesn't exist.
+ * or return `Option.none()` if the key doesn't exist.
  *
  * @example
  * ```ts
@@ -553,8 +553,8 @@ export const get: {
  *
  * const input: Record<string, number> = { a: 3 }
  *
- * Record.modify(input, "a", f) // { a: 6 }
- * Record.modify(input, "b", f) // undefined
+ * Record.modify(input, "a", f) // Option.some({ a: 6 })
+ * Record.modify(input, "b", f) // Option.none()
  * ```
  *
  * @category utils
@@ -563,7 +563,7 @@ export const get: {
 export const modify: {
   /**
    * Apply a function to the element at the specified key, creating a new record,
-   * or return `undefined` if the key doesn't exist.
+   * or return `Option.none()` if the key doesn't exist.
    *
    * @example
    * ```ts
@@ -573,17 +573,17 @@ export const modify: {
    *
    * const input: Record<string, number> = { a: 3 }
    *
-   * Record.modify(input, "a", f) // { a: 6 }
-   * Record.modify(input, "b", f) // undefined
+   * Record.modify(input, "a", f) // Option.some({ a: 6 })
+   * Record.modify(input, "b", f) // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, A, B>(key: NoInfer<K>, f: (a: A) => B): (self: ReadonlyRecord<K, A>) => Record<K, A | B> | undefined
+  <K extends string | symbol, A, B>(key: NoInfer<K>, f: (a: A) => B): (self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
   /**
    * Apply a function to the element at the specified key, creating a new record,
-   * or return `undefined` if the key doesn't exist.
+   * or return `Option.none()` if the key doesn't exist.
    *
    * @example
    * ```ts
@@ -593,23 +593,23 @@ export const modify: {
    *
    * const input: Record<string, number> = { a: 3 }
    *
-   * Record.modify(input, "a", f) // { a: 6 }
-   * Record.modify(input, "b", f) // undefined
+   * Record.modify(input, "a", f) // Option.some({ a: 6 })
+   * Record.modify(input, "b", f) // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Record<K, A | B> | undefined
+  <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,
   <K extends string | symbol, A, B>(
     self: ReadonlyRecord<K, A>,
     key: NoInfer<K>,
     f: (a: A) => B
-  ): Record<K, A | B> | undefined => {
-    if (!has(self, key)) return undefined
-    return { ...self, [key]: f(self[key]) }
+  ): Option.Option<Record<K, A | B>> => {
+    if (!has(self, key)) return Option.none()
+    return Option.some({ ...self, [key]: f(self[key]) })
   }
 )
 
@@ -620,8 +620,8 @@ export const modify: {
  * ```ts
  * import { Record } from "effect"
  *
- * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // { a: 10, b: 2, c: 3 }
- * Record.replace(Record.empty<string>(), "a", 10) // undefined
+ * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
+ * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
  * ```
  *
  * @category utils
@@ -635,14 +635,14 @@ export const replace: {
    * ```ts
    * import { Record } from "effect"
    *
-   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // { a: 10, b: 2, c: 3 }
-   * Record.replace(Record.empty<string>(), "a", 10) // undefined
+   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
+   * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, B>(key: NoInfer<K>, b: B): <A>(self: ReadonlyRecord<K, A>) => Record<K, A | B> | undefined
+  <K extends string | symbol, B>(key: NoInfer<K>, b: B): <A>(self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
   /**
    * Replaces a value in the record with the new value passed as parameter.
    *
@@ -650,26 +650,26 @@ export const replace: {
    * ```ts
    * import { Record } from "effect"
    *
-   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // { a: 10, b: 2, c: 3 }
-   * Record.replace(Record.empty<string>(), "a", 10) // undefined
+   * Record.replace({ a: 1, b: 2, c: 3 }, "a", 10) // Option.some({ a: 10, b: 2, c: 3 })
+   * Record.replace(Record.empty<string>(), "a", 10) // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, b: B): Record<K, A | B> | undefined
+  <K extends string | symbol, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, b: B): Option.Option<Record<K, A | B>>
 } = dual(
   3,
   <K extends string | symbol, A, B>(
     self: ReadonlyRecord<K, A>,
     key: NoInfer<K>,
     b: B
-  ): Record<K, A | B> | undefined => modify(self, key, () => b)
+  ): Option.Option<Record<K, A | B>> => modify(self, key, () => b)
 )
 
 /**
- * If the given key exists in the record, returns a new record with the key removed,
- * otherwise returns `undefined`.
+ * If the given key exists in the record, returns a new record with the key removed.
+ * If the key does not exist, returns a shallow copy of the original record.
  *
  * @example
  * ```ts
@@ -684,8 +684,8 @@ export const replace: {
  */
 export const remove: {
   /**
-   * If the given key exists in the record, returns a new record with the key removed,
-   * otherwise returns `undefined`.
+   * If the given key exists in the record, returns a new record with the key removed.
+   * If the key does not exist, returns a shallow copy of the original record.
    *
    * @example
    * ```ts
@@ -700,8 +700,8 @@ export const remove: {
    */
   <K extends string | symbol, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => Record<Exclude<K, X>, A>
   /**
-   * If the given key exists in the record, returns a new record with the key removed,
-   * otherwise returns `undefined`.
+   * If the given key exists in the record, returns a new record with the key removed.
+   * If the key does not exist, returns a shallow copy of the original record.
    *
    * @example
    * ```ts
@@ -730,7 +730,7 @@ export const remove: {
 /**
  * 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 `undefined`.
+ * If the key is not present, returns `Option.none()`.
  *
  * @example
  * ```ts
@@ -738,8 +738,8 @@ export const remove: {
  *
  * const input: Record<string, number> = { a: 1, b: 2 }
  *
- * Record.pop(input, "a") // [1, { b: 2 }]
- * Record.pop(input, "c") // undefined
+ * Record.pop(input, "a") // Option.some([1, { b: 2 }])
+ * Record.pop(input, "c") // Option.none()
  * ```
  *
  * @category utils
@@ -749,7 +749,7 @@ export const pop: {
   /**
    * 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 `undefined`.
+   * If the key is not present, returns `Option.none()`.
    *
    * @example
    * ```ts
@@ -757,18 +757,18 @@ export const pop: {
    *
    * const input: Record<string, number> = { a: 1, b: 2 }
    *
-   * Record.pop(input, "a") // [1, { b: 2 }]
-   * Record.pop(input, "c") // undefined
+   * Record.pop(input, "a") // Option.some([1, { b: 2 }])
+   * Record.pop(input, "c") // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => [A, Record<Exclude<K, X>, A>] | undefined
+  <K extends string | symbol, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => Option.Option<[A, Record<Exclude<K, X>, A>]>
   /**
    * 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 `undefined`.
+   * If the key is not present, returns `Option.none()`.
    *
    * @example
    * ```ts
@@ -776,18 +776,19 @@ export const pop: {
    *
    * const input: Record<string, number> = { a: 1, b: 2 }
    *
-   * Record.pop(input, "a") // [1, { b: 2 }]
-   * Record.pop(input, "c") // undefined
+   * Record.pop(input, "a") // Option.some([1, { b: 2 }])
+   * Record.pop(input, "c") // Option.none()
    * ```
    *
    * @category utils
    * @since 2.0.0
    */
-  <K extends string | symbol, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): [A, Record<Exclude<K, X>, A>] | undefined
+  <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
-): [A, Record<Exclude<K, X>, A>] | undefined => has(self, key) ? [self[key], remove(self, key)] : undefined)
+): Option.Option<[A, Record<Exclude<K, X>, A>]> =>
+  has(self, key) ? Option.some([self[key], remove(self, key)]) : Option.none())
 
 /**
  * Maps a record into another record by applying a transformation function to each of its values.
@@ -1002,16 +1003,16 @@ export const mapEntries: {
 )
 
 /**
- * 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.
+ * Transforms a record by applying the function `f` to each key and value in the original record.
+ * If the function succeeds, the key-value pair is included in the output record.
  *
  * @example
  * ```ts
- * import { Option, Record } from "effect"
+ * import { Record, Result } from "effect"
  * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+ * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
  * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
  * ```
  *
@@ -1020,52 +1021,52 @@ export const mapEntries: {
  */
 export const filterMap: {
   /**
-   * 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.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <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, X>(f: (input: A, key: K) => Result<B, X>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
-   * 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.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(self: ReadonlyRecord<K, A>, f: (input: A, key: K) => Result<B, X>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
-  <K extends string, A, B>(
+  <K extends string, A, B, X>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Option.Option<B>
+    f: (input: A, key: K) => Result<B, X>
   ): 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
+      const result = f(self[key], key)
+      if (R.isSuccess(result)) {
+        out[key] = result.success
       }
     }
     return out
@@ -1187,9 +1188,18 @@ export const filter: {
  */
 export const getSomes: <K extends string, A>(
   self: ReadonlyRecord<K, Option.Option<A>>
-) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = filterMap(
-  identity
-)
+) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = <K extends string, A>(
+  self: ReadonlyRecord<K, Option.Option<A>>
+): Record<ReadonlyRecord.NonLiteralKey<K>, A> => {
+  const out: Record<string, A> = empty()
+  for (const key of keys(self)) {
+    const option = self[key]
+    if (Option.isSome(option)) {
+      out[key] = option.value
+    }
+  }
+  return out
+}
 
 /**
  * Given a record with `Result` values, returns a new record containing only the `Err` values, preserving the original keys.
@@ -1262,7 +1272,7 @@ export const getSuccesses = <K extends string, A, E>(
 }
 
 /**
- * Partitions the elements of a record 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 filter, and those that don't.
  *
  * @example
  * ```ts
@@ -1271,15 +1281,15 @@ export const getSuccesses = <K extends string, A, E>(
  *
  * const x = { a: 1, b: 2, c: 3 }
  * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+ * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
  * ```
  *
  * @category filtering
  * @since 2.0.0
  */
-export const partitionMap: {
+export const partition: {
   /**
-   * Partitions the elements of a record 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 filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1288,17 +1298,17 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(f: (a: A, key: K) => Result<C, B>): (
+  <K extends string, A, B, C>(f: (input: A, key: K) => Result<C, B>): (
     self: ReadonlyRecord<K, A>
   ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   /**
-   * Partitions the elements of a record 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 filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1307,18 +1317,18 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Result<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
+  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (input: A, key: K) => Result<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
   <K extends string, A, B, C>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Result<C, B>
+    f: (input: A, key: K) => Result<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()
@@ -1354,126 +1364,7 @@ export const partitionMap: {
  */
 export const separate: <K extends string, A, B>(
   self: ReadonlyRecord<K, Result<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.
- *
- * @example
- * ```ts
- * import { Record } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
- *   [{ a: 1 }, { b: 3 }]
- * )
- * ```
- *
- * @category filtering
- * @since 2.0.0
- */
-export const partition: {
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
-    self: ReadonlyRecord<K, A>
-  ) => [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A>(predicate: (a: NoInfer<A>, key: K) => boolean): (
-    self: ReadonlyRecord<K, A>
-  ) => [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(self: ReadonlyRecord<K, A>, refinement: (a: A, key: K) => a is B): [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <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>]
-} = dual(
-  2,
-  <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 {
-        left[key] = self[key]
-      }
-    }
-    return [left, right]
-  }
-)
+) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partition(identity)
 
 /**
  * Retrieve the keys of a given record as an array.
@@ -2268,7 +2159,7 @@ export const findFirst: {
    * @category elements
    * @since 3.14.0
    */
-  <K extends string | symbol, V, V2 extends V>(refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): (self: ReadonlyRecord<K, V>) => [K, V2] | undefined
+  <K extends string | symbol, V, V2 extends V>(refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2): (self: ReadonlyRecord<K, V>) => Option.Option<[K, V2]>
   /**
    * Returns the first entry that satisfies the specified
    * predicate, or `None` if no such entry exists.
@@ -2288,7 +2179,7 @@ export const findFirst: {
    * @category elements
    * @since 3.14.0
    */
-  <K extends string | symbol, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: ReadonlyRecord<K, V>) => [K, V] | undefined
+  <K extends string | symbol, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean): (self: ReadonlyRecord<K, V>) => Option.Option<[K, V]>
   /**
    * Returns the first entry that satisfies the specified
    * predicate, or `None` if no such entry exists.
@@ -2311,7 +2202,7 @@ export const findFirst: {
   <K extends string | symbol, V, V2 extends V>(
     self: ReadonlyRecord<K, V>,
     refinement: (value: NoInfer<V>, key: NoInfer<K>) => value is V2
-  ): [K, V2] | undefined
+  ): Option.Option<[K, V2]>
   /**
    * Returns the first entry that satisfies the specified
    * predicate, or `None` if no such entry exists.
@@ -2334,16 +2225,20 @@ export const findFirst: {
   <K extends string | symbol, V>(
     self: ReadonlyRecord<K, V>,
     predicate: (value: NoInfer<V>, key: NoInfer<K>) => boolean
-  ): [K, V] | undefined
+  ): Option.Option<[K, V]>
 } = dual(
   2,
-  <K extends string | symbol, V>(self: ReadonlyRecord<K, V>, f: (value: V, key: K) => boolean): [K, V] | undefined => {
+  <K extends string | symbol, V>(
+    self: ReadonlyRecord<K, V>,
+    f: (value: V, key: K) => boolean
+  ): Option.Option<[K, V]> => {
     const k = keys(self)
     for (let i = 0; i < k.length; i++) {
       const key = k[i]
       if (f(self[key], key)) {
-        return [key, self[key]]
+        return Option.some([key, self[key]])
       }
     }
+    return Option.none()
   }
 )