effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/HashMap.ts

@@ -7,6 +7,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import * as internal from "./internal/hashMap.ts"
 import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import type { Result } from "./Result.ts"
 import type { NoInfer } from "./Types.ts"
 
 const TypeId = internal.HashMapTypeId
@@ -2011,18 +2012,18 @@ export const filter: {
 export const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A> = internal.compact
 
 /**
- * Maps over the entries of the `HashMap` using the specified partial function
- * and filters out `None` values.
+ * Maps over the entries of the `HashMap` using the specified filter and keeps
+ * only successful results.
  *
  * @example
  * ```ts
  * import * as HashMap from "effect/HashMap"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
  * const map2 = HashMap.filterMap(
  *   map1,
- *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+ *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
  * )
  *
  * console.log(HashMap.size(map2)) // 2
@@ -2035,18 +2036,18 @@ export const compact: <K, A>(self: HashMap<K, Option<A>>) => HashMap<K, A> = int
  */
 export const filterMap: {
   /**
-   * Maps over the entries of the `HashMap` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `HashMap` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
    * const map2 = HashMap.filterMap(
    *   map1,
-   *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+   *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
    * )
    *
    * console.log(HashMap.size(map2)) // 2
@@ -2057,20 +2058,20 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>
+  <A, K, B, X>(f: (input: A, key: K) => Result<B, X>): (self: HashMap<K, A>) => HashMap<K, B>
   /**
-   * Maps over the entries of the `HashMap` using the specified partial function
-   * and filters out `None` values.
+   * Maps over the entries of the `HashMap` using the specified filter and keeps
+   * only successful results.
    *
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3], ["d", 4])
    * const map2 = HashMap.filterMap(
    *   map1,
-   *   (value) => value % 2 === 0 ? Option.some(value * 2) : Option.none()
+   *   (value) => value % 2 === 0 ? Result.succeed(value * 2) : Result.failVoid
    * )
    *
    * console.log(HashMap.size(map2)) // 2
@@ -2081,7 +2082,7 @@ export const filterMap: {
    * @since 2.0.0
    * @category filtering
    */
-  <K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>
+  <K, A, B, X>(self: HashMap<K, A>, f: (input: A, key: K) => Result<B, X>): HashMap<K, B>
 } = internal.filterMap
 
 /**
@@ -2091,10 +2092,12 @@ export const filterMap: {
  * @example
  * ```ts
  * import * as HashMap from "effect/HashMap"
+ * import * as Option from "effect/Option"
  *
  * const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
  * const result = HashMap.findFirst(map, (value) => value > 1)
- * console.log(result) // [ 'c', 3 ]
+ * console.log(result) // Option.some(["c", 3])
+ * console.log(Option.getOrElse(result, () => ["", 0])) // ["c", 3]
  * ```
  *
  * @category elements
@@ -2108,16 +2111,18 @@ export const findFirst: {
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
+   * import * as Option from "effect/Option"
    *
    * const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
    * const result = HashMap.findFirst(map, (value) => value > 1)
-   * console.log(result) // [ 'c', 3 ]
+   * console.log(result) // Option.some(["c", 3])
+   * console.log(Option.getOrElse(result, () => ["", 0])) // ["c", 3]
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => [K, A] | undefined
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
   /**
    * Returns the first element that satisfies the specified
    * predicate, or `None` if no such element exists.
@@ -2125,16 +2130,18 @@ export const findFirst: {
    * @example
    * ```ts
    * import * as HashMap from "effect/HashMap"
+   * import * as Option from "effect/Option"
    *
    * const map = HashMap.make(["a", 1], ["b", 2], ["c", 3])
    * const result = HashMap.findFirst(map, (value) => value > 1)
-   * console.log(result) // [ 'c', 3 ]
+   * console.log(result) // Option.some(["c", 3])
+   * console.log(Option.getOrElse(result, () => ["", 0])) // ["c", 3]
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): [K, A] | undefined
+  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>
 } = internal.findFirst
 
 /**

package/src/Inspectable.ts

@@ -37,9 +37,8 @@
  *
  * @since 2.0.0
  */
-import { format } from "./Formatter.ts"
+import { format, formatJson } from "./Formatter.ts"
 import * as Predicate from "./Predicate.ts"
-import * as Redactable from "./Redactable.ts"
 import { redact } from "./Redactable.ts"
 
 /**
@@ -176,31 +175,12 @@ export const toStringUnknown = (u: unknown, whitespace: number | string | undefi
     return u
   }
   try {
-    return typeof u === "object" ? stringifyCircular(u, whitespace) : String(u)
+    return typeof u === "object" ? formatJson(u, { space: whitespace }) : String(u)
   } catch {
     return String(u)
   }
 }
 
-/**
- * @since 2.0.0
- */
-export const stringifyCircular = (obj: unknown, whitespace?: number | string | undefined): string => {
-  let cache: Array<unknown> = []
-  const retVal = JSON.stringify(
-    obj,
-    (_key, value) =>
-      typeof value === "object" && value !== null
-        ? cache.includes(value)
-          ? undefined // circular reference
-          : cache.push(value) && Redactable.redact(value)
-        : value,
-    whitespace
-  )
-  ;(cache as any) = undefined
-  return retVal
-}
-
 /**
  * A base prototype object that implements the {@link Inspectable} interface.
  *

package/src/Iterable.ts

@@ -12,7 +12,7 @@
  *
  * @example
  * ```ts
- * import { Iterable } from "effect"
+ * import { Iterable, Option } from "effect"
  *
  * // Create iterables
  * const numbers = Iterable.range(1, 5)
@@ -22,7 +22,7 @@
  * console.log(Array.from(filtered)) // [6, 8, 10]
  *
  * // Infinite iterables
- * const fibonacci = Iterable.unfold([0, 1], ([a, b]) => [a, [b, a + b]])
+ * const fibonacci = Iterable.unfold([0, 1], ([a, b]) => Option.some([a, [b, a + b]]))
  * const first10 = Iterable.take(fibonacci, 10)
  * console.log(Array.from(first10)) // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  * ```
@@ -32,7 +32,7 @@
 
 import type { NonEmptyArray } from "./Array.ts"
 import * as Equal from "./Equal.ts"
-import { dual, identity } from "./Function.ts"
+import { dual } from "./Function.ts"
 import type { Option } from "./Option.ts"
 import * as O from "./Option.ts"
 import { isBoolean } from "./Predicate.ts"
@@ -3114,21 +3114,21 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
 })
 
 /**
- * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+ * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
  *
  * This combines mapping and filtering in a single operation - the function is applied to each element,
- * and only elements that result in Option.some are included in the result.
+ * and only elements that result in `Result.succeed` are included in the result.
  *
  * @example
  * ```ts
  * import { Iterable } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * // Parse strings to numbers, keeping only valid ones
  * const strings = ["1", "2", "invalid", "4", "not-a-number"]
  * const numbers = Iterable.filterMap(strings, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Array.from(numbers)) // [1, 2, 4]
  *
@@ -3142,7 +3142,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  * const adultEmails = Iterable.filterMap(
  *   users,
  *   (user) =>
- *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+ *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
  * )
  * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
  *
@@ -3150,7 +3150,7 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  * const items = ["a", "b", "c", "d", "e"]
  * const evenIndexItems = Iterable.filterMap(
  *   items,
- *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+ *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
  * )
  * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
  * ```
@@ -3160,21 +3160,21 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
  */
 export const filterMap: {
   /**
-   * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+   * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
-   * and only elements that result in Option.some are included in the result.
+   * and only elements that result in `Result.succeed` are included in the result.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse strings to numbers, keeping only valid ones
    * const strings = ["1", "2", "invalid", "4", "not-a-number"]
    * const numbers = Iterable.filterMap(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 4]
    *
@@ -3188,7 +3188,7 @@ export const filterMap: {
    * const adultEmails = Iterable.filterMap(
    *   users,
    *   (user) =>
-   *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+   *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
    * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
    *
@@ -3196,7 +3196,7 @@ export const filterMap: {
    * const items = ["a", "b", "c", "d", "e"]
    * const evenIndexItems = Iterable.filterMap(
    *   items,
-   *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+   *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
    * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
    * ```
@@ -3204,23 +3204,23 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: (input: A, i: number) => Result<B, X>): (self: Iterable<A>) => Iterable<B>
   /**
-   * Transforms elements of an iterable using a function that returns an Option, keeping only the Some values.
+   * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
-   * and only elements that result in Option.some are included in the result.
+   * and only elements that result in `Result.succeed` are included in the result.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse strings to numbers, keeping only valid ones
    * const strings = ["1", "2", "invalid", "4", "not-a-number"]
    * const numbers = Iterable.filterMap(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 4]
    *
@@ -3234,7 +3234,7 @@ export const filterMap: {
    * const adultEmails = Iterable.filterMap(
    *   users,
    *   (user) =>
-   *     user.age >= 18 && user.email ? Option.some(user.email) : Option.none()
+   *     user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
    * )
    * console.log(Array.from(adultEmails)) // ["alice@example.com", "charlie@example.com"]
    *
@@ -3242,7 +3242,7 @@ export const filterMap: {
    * const items = ["a", "b", "c", "d", "e"]
    * const evenIndexItems = Iterable.filterMap(
    *   items,
-   *   (item, i) => i % 2 === 0 ? Option.some(`${i}: ${item}`) : Option.none()
+   *   (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
    * )
    * console.log(Array.from(evenIndexItems)) // ["0: a", "2: c", "4: e"]
    * ```
@@ -3250,10 +3250,10 @@ export const filterMap: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B>
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B>
 } = dual(
   2,
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B> => ({
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B> => ({
     [Symbol.iterator]() {
       const iterator = self[Symbol.iterator]()
       let i = 0
@@ -3261,9 +3261,9 @@ export const filterMap: {
         next() {
           let result = iterator.next()
           while (!result.done) {
-            const b = f(result.value, i++)
-            if (O.isSome(b)) {
-              return { done: false, value: b.value }
+            const next = f(result.value, i++)
+            if (R.isSuccess(next)) {
+              return { done: false, value: next.success }
             }
             result = iterator.next()
           }
@@ -3275,18 +3275,18 @@ export const filterMap: {
 )
 
 /**
- * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+ * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
  *
  * @example
  * ```ts
  * import { Iterable } from "effect"
- * import * as Option from "effect/Option"
+ * import * as Result from "effect/Result"
  *
  * // Parse numbers until we hit an invalid one
  * const strings = ["1", "2", "3", "invalid", "4", "5"]
  * const numbers = Iterable.filterMapWhile(strings, (s) => {
  *   const num = parseInt(s)
- *   return isNaN(num) ? Option.none() : Option.some(num)
+ *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
  * })
  * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
  *
@@ -3294,7 +3294,7 @@ export const filterMap: {
  * const values = [2, 4, 6, 7, 8, 10]
  * const doubledEvens = Iterable.filterMapWhile(
  *   values,
- *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+ *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
  * )
  * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
  *
@@ -3302,7 +3302,7 @@ export const filterMap: {
  * const letters = ["a", "b", "c", "d", "e"]
  * const indexedUntilC = Iterable.filterMapWhile(
  *   letters,
- *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+ *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
  * )
  * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
  * ```
@@ -3312,18 +3312,18 @@ export const filterMap: {
  */
 export const filterMapWhile: {
   /**
-   * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+   * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse numbers until we hit an invalid one
    * const strings = ["1", "2", "3", "invalid", "4", "5"]
    * const numbers = Iterable.filterMapWhile(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
    *
@@ -3331,7 +3331,7 @@ export const filterMapWhile: {
    * const values = [2, 4, 6, 7, 8, 10]
    * const doubledEvens = Iterable.filterMapWhile(
    *   values,
-   *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+   *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
    * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
    *
@@ -3339,7 +3339,7 @@ export const filterMapWhile: {
    * const letters = ["a", "b", "c", "d", "e"]
    * const indexedUntilC = Iterable.filterMapWhile(
    *   letters,
-   *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+   *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
    * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
    * ```
@@ -3347,20 +3347,20 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Iterable<B>
+  <A, B, X>(f: (input: A, i: number) => Result<B, X>): (self: Iterable<A>) => Iterable<B>
   /**
-   * Transforms all elements of the `Iterable` for as long as the specified function returns some value
+   * Transforms all elements of the `Iterable` for as long as the specified function succeeds.
    *
    * @example
    * ```ts
    * import { Iterable } from "effect"
-   * import * as Option from "effect/Option"
+   * import * as Result from "effect/Result"
    *
    * // Parse numbers until we hit an invalid one
    * const strings = ["1", "2", "3", "invalid", "4", "5"]
    * const numbers = Iterable.filterMapWhile(strings, (s) => {
    *   const num = parseInt(s)
-   *   return isNaN(num) ? Option.none() : Option.some(num)
+   *   return isNaN(num) ? Result.failVoid : Result.succeed(num)
    * })
    * console.log(Array.from(numbers)) // [1, 2, 3] (stops at "invalid")
    *
@@ -3368,7 +3368,7 @@ export const filterMapWhile: {
    * const values = [2, 4, 6, 7, 8, 10]
    * const doubledEvens = Iterable.filterMapWhile(
    *   values,
-   *   (n) => n % 2 === 0 ? Option.some(n * 2) : Option.none()
+   *   (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
    * )
    * console.log(Array.from(doubledEvens)) // [4, 8, 12] (stops at 7)
    *
@@ -3376,7 +3376,7 @@ export const filterMapWhile: {
    * const letters = ["a", "b", "c", "d", "e"]
    * const indexedUntilC = Iterable.filterMapWhile(
    *   letters,
-   *   (letter, i) => letter !== "c" ? Option.some(`${i}: ${letter}`) : Option.none()
+   *   (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
    * )
    * console.log(Array.from(indexedUntilC)) // ["0: a", "1: b"] (stops at "c")
    * ```
@@ -3384,8 +3384,8 @@ export const filterMapWhile: {
    * @category filtering
    * @since 2.0.0
    */
-  <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Iterable<B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => ({
+  <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>): Iterable<B>
+} = dual(2, <A, B, X>(self: Iterable<A>, f: (input: A, i: number) => Result<B, X>) => ({
   [Symbol.iterator]() {
     const iterator = self[Symbol.iterator]()
     let i = 0
@@ -3395,9 +3395,9 @@ export const filterMapWhile: {
         if (result.done) {
           return { done: true, value: undefined }
         }
-        const b = f(result.value, i++)
-        if (O.isSome(b)) {
-          return { done: false, value: b.value }
+        const next = f(result.value, i++)
+        if (R.isSuccess(next)) {
+          return { done: false, value: next.success }
         }
         return { done: true, value: undefined }
       }
@@ -3425,7 +3425,25 @@ export const filterMapWhile: {
  * @category filtering
  * @since 2.0.0
  */
-export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap(identity)
+export const getSomes = <A>(self: Iterable<Option<A>>): Iterable<A> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (O.isSome(result.value)) {
+              return { done: false, value: result.value.value }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Retrieves the `Err` values from an `Iterable` of `Result`s.
@@ -3451,7 +3469,25 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap
  * @category filtering
  * @since 2.0.0
  */
-export const getFailures = <R, L>(self: Iterable<Result<R, L>>): Iterable<L> => filterMap(self, R.getFailure)
+export const getFailures = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<L> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (R.isFailure(result.value)) {
+              return { done: false, value: result.value.failure }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Retrieves the `Ok` values from an `Iterable` of `Result`s.
@@ -3477,7 +3513,25 @@ export const getFailures = <R, L>(self: Iterable<Result<R, L>>): Iterable<L> =>
  * @category filtering
  * @since 2.0.0
  */
-export const getSuccesses = <R, L>(self: Iterable<Result<R, L>>): Iterable<R> => filterMap(self, R.getSuccess)
+export const getSuccesses = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<R0> => {
+  return {
+    [Symbol.iterator]() {
+      const iterator = self[Symbol.iterator]()
+      return {
+        next() {
+          let result = iterator.next()
+          while (!result.done) {
+            if (R.isSuccess(result.value)) {
+              return { done: false, value: result.value.success }
+            }
+            result = iterator.next()
+          }
+          return { done: true, value: undefined }
+        }
+      }
+    }
+  }
+}
 
 /**
  * Filters an iterable to only include elements that match a predicate.
@@ -3855,7 +3909,7 @@ export const flatMapNullishOr: {
   <A, B>(self: Iterable<A>, f: (a: A) => B): Iterable<NonNullable<B>> =>
     filterMap(self, (a) => {
       const b = f(a)
-      return b == null ? O.none() : O.some(b)
+      return b == null ? R.failVoid : R.succeed(b)
     })
 )
 
@@ -4000,31 +4054,31 @@ export const some: {
  * next element and state.
  *
  * This is useful for creating iterables from a generating function that
- * maintains state. The function should return `[value, nextState]` to continue
- * or `undefined` to stop.
+ * maintains state. The function should return `Option.some([value, nextState])`
+ * to continue or `Option.none()` to stop.
  *
  * @example
  * ```ts
- * import { Iterable } from "effect"
+ * import { Iterable, Option } from "effect"
  *
  * // Generate Fibonacci sequence
- * const fibonacci = Iterable.unfold([0, 1], ([a, b]) => [a, [b, a + b]])
+ * const fibonacci = Iterable.unfold([0, 1], ([a, b]) => Option.some([a, [b, a + b]]))
  * const first10Fib = Iterable.take(fibonacci, 10)
  * console.log(Array.from(first10Fib)) // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  *
  * // Generate powers of 2 up to a limit
- * const powersOf2 = Iterable.unfold(1, (n) => n <= 1000 ? [n, n * 2] : undefined)
+ * const powersOf2 = Iterable.unfold(1, (n) => n <= 1000 ? Option.some([n, n * 2]) : Option.none())
  * console.log(Array.from(powersOf2)) // [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
  *
  * // Generate countdown
- * const countdown = Iterable.unfold(5, (n) => n > 0 ? [n, n - 1] : undefined)
+ * const countdown = Iterable.unfold(5, (n) => n > 0 ? Option.some([n, n - 1]) : Option.none())
  * console.log(Array.from(countdown)) // [5, 4, 3, 2, 1]
  *
  * // Generate collatz sequence
  * const collatz = Iterable.unfold(7, (n) => {
- *   if (n === 1) return undefined
+ *   if (n === 1) return Option.none()
  *   const next = n % 2 === 0 ? n / 2 : n * 3 + 1
- *   return [n, next]
+ *   return Option.some([n, next])
  * })
  * console.log(Array.from(collatz)) // [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2]
  * ```
@@ -4032,16 +4086,16 @@ export const some: {
  * @category constructors
  * @since 2.0.0
  */
-export const unfold = <B, A>(b: B, f: (b: B) => readonly [A, B] | undefined): Iterable<A> => ({
+export const unfold = <B, A>(b: B, f: (b: B) => Option<readonly [A, B]>): Iterable<A> => ({
   [Symbol.iterator]() {
     let next = b
     return {
       next() {
         const ab = f(next)
-        if (ab === undefined) {
+        if (O.isNone(ab)) {
           return { done: true, value: undefined }
         }
-        const [a, b] = ab
+        const [a, b] = ab.value
         next = b
         return { done: false, value: a }
       }