effect 4.0.0-beta.30 → 4.0.0-beta.32

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]
  * ```
@@ -4054,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]
  * ```
@@ -4086,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 }
       }

package/src/Latch.ts

@@ -26,7 +26,7 @@ export interface Latch {
   /** open the latch, releasing all fibers waiting on it */
   readonly open: Effect.Effect<boolean>
   /** open the latch, releasing all fibers waiting on it */
-  readonly openUnsafe: () => boolean
+  openUnsafe(this: Latch): boolean
   /** release all fibers waiting on the latch, without opening it */
   readonly release: Effect.Effect<boolean>
   /** wait for the latch to be opened */
@@ -34,9 +34,9 @@ export interface Latch {
   /** close the latch */
   readonly close: Effect.Effect<boolean>
   /** close the latch */
-  readonly closeUnsafe: () => boolean
+  closeUnsafe(this: Latch): boolean
   /** only run the given effect when the latch is open */
-  readonly whenOpen: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  whenOpen<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 }
 
 /**
@@ -110,3 +110,85 @@ export const makeUnsafe: (open?: boolean | undefined) => Latch = internal.makeLa
  * @since 3.8.0
  */
 export const make: (open?: boolean | undefined) => Effect.Effect<Latch> = internal.makeLatch
+
+/**
+ * Opens the latch, releasing all fibers waiting on it.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const open = (self: Latch): Effect.Effect<boolean> => self.open
+
+/**
+ * Opens the latch, releasing all fibers waiting on it.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const openUnsafe = (self: Latch): boolean => self.openUnsafe()
+
+/**
+ * Releases all fibers waiting on the latch, without opening it.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const release = (self: Latch): Effect.Effect<boolean> => self.release
+
+const _await = (self: Latch): Effect.Effect<void> => self.await
+
+export {
+  /**
+   * Waits for the latch to be opened.
+   *
+   * @category getters
+   * @since 4.0.0
+   */
+  _await as await
+}
+
+/**
+ * Closes the latch.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const close = (self: Latch): Effect.Effect<boolean> => self.close
+
+/**
+ * Closes the latch.
+ *
+ * @category unsafe
+ * @since 4.0.0
+ */
+export const closeUnsafe = (self: Latch): boolean => self.closeUnsafe()
+
+/**
+ * Runs the given effect only when the latch is open.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const whenOpen: {
+  /**
+   * Runs the given effect only when the latch is open.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  (self: Latch): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /**
+   * Runs the given effect only when the latch is open.
+   *
+   * @category combinators
+   * @since 4.0.0
+   */
+  <A, E, R>(self: Latch, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+} = ((...args: Array<any>) => {
+  if (args.length === 1) {
+    const [self] = args
+    return (effect: Effect.Effect<any, any, any>) => self.whenOpen(effect)
+  }
+  const [self, effect] = args
+  return self.whenOpen(effect)
+}) as any

package/src/Layer.ts

@@ -2447,6 +2447,127 @@ export const flatMap: {
     )
   ))
 
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tap: {
+  /**
+   * Performs the specified effect if this layer succeeds.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <ROut, XR extends ROut, RIn2, E2, X>(f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer succeeds.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
+    self: Layer<ROut, E, RIn>,
+    f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+  ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.flatMap(
+      self.build(memoMap, scope),
+      (context) => Scope.provide(internalEffect.as(f(context as ServiceMap.ServiceMap<XR>), context), scope)
+    )
+  ))
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tapError: {
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (e: XE) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catch_(
+      self.build(memoMap, scope),
+      (error) => Scope.provide(internalEffect.andThen(f(error as XE), internalEffect.fail(error)), scope)
+    )
+  ))
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Layer.tapErrorCause`
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export const tapCause: {
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * **Previously Known As**
+   *
+   * This API replaces the following from Effect 3.x:
+   *
+   * - `Layer.tapErrorCause`
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * **Previously Known As**
+   *
+   * This API replaces the following from Effect 3.x:
+   *
+   * - `Layer.tapErrorCause`
+   *
+   * @since 4.0.0
+   * @category sequencing
+   */
+  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+    self: Layer<ROut, E, RIn>,
+    f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+  ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  self: Layer<ROut, E, RIn>,
+  f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catchCause(
+      self.build(memoMap, scope),
+      (cause) =>
+        Scope.provide(internalEffect.andThen(f(cause as Cause.Cause<XE>), internalEffect.failCause(cause)), scope)
+    )
+  ))
+
 /**
  * Translates effect failure into death of the fiber, making all failures
  * unchecked and not a part of the type of the layer.
@@ -3062,7 +3183,7 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * }>()("UserService") {}
  *
  * // Create a partial mock - only implement what you need for testing
- * const testUserLayer = Layer.mock(UserService)({
+ * const testUserLayer = Layer.mock(UserService, {
  *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
  *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
  *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
@@ -3086,24 +3207,128 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * @since 4.0.0
  * @category Testing
  */
-export const mock =
-  <I, S extends object>(service: ServiceMap.Key<I, S>) => (implementation: PartialEffectful<S>): Layer<I> =>
-    succeed(service)(
-      new Proxy({ ...implementation as object } as S, {
-        get(target, prop, _receiver) {
-          if (prop in target) {
-            return target[prop as keyof S]
-          }
-          const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
-          const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
-          error.name = "UnimplementedError"
-          return makeUnimplemented(error)
-        },
-        has: constTrue
-      })
-    )
+export const mock: {
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an unimplemented defect when called.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Layer, ServiceMap } from "effect"
+   *
+   * class UserService extends ServiceMap.Service<UserService, {
+   *   readonly config: { apiUrl: string }
+   *   readonly getUser: (
+   *     id: string
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+   *   readonly updateUser: (
+   *     id: string,
+   *     data: object
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   * }>()("UserService") {}
+   *
+   * // Create a partial mock - only implement what you need for testing
+   * const testUserLayer = Layer.mock(UserService, {
+   *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
+   *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
+   *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
+   * })
+   *
+   * // Use in tests
+   * const testProgram = Effect.gen(function*() {
+   *   const userService = yield* UserService
+   *
+   *   // This works - we provided an implementation
+   *   const user = yield* userService.getUser("123")
+   *   console.log(user.name) // "Test User"
+   *
+   *   // This would throw - we didn't implement deleteUser
+   *   // yield* userService.deleteUser("123") // UnimplementedError
+   * }).pipe(
+   *   Effect.provide(testUserLayer)
+   * )
+   * ```
+   *
+   * @since 4.0.0
+   * @category Testing
+   */
+  <I, S extends object>(service: ServiceMap.Key<I, S>): (implementation: PartialEffectful<S>) => Layer<I>
+  /**
+   * Creates a mock layer for testing purposes. You can provide a partial
+   * implementation of the service, and any methods not provided will
+   * throw an unimplemented defect when called.
+   *
+   * @example
+   * ```ts
+   * import { Effect, Layer, ServiceMap } from "effect"
+   *
+   * class UserService extends ServiceMap.Service<UserService, {
+   *   readonly config: { apiUrl: string }
+   *   readonly getUser: (
+   *     id: string
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+   *   readonly updateUser: (
+   *     id: string,
+   *     data: object
+   *   ) => Effect.Effect<{ id: string; name: string }, Error>
+   * }>()("UserService") {}
+   *
+   * // Create a partial mock - only implement what you need for testing
+   * const testUserLayer = Layer.mock(UserService, {
+   *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
+   *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
+   *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
+   * })
+   *
+   * // Use in tests
+   * const testProgram = Effect.gen(function*() {
+   *   const userService = yield* UserService
+   *
+   *   // This works - we provided an implementation
+   *   const user = yield* userService.getUser("123")
+   *   console.log(user.name) // "Test User"
+   *
+   *   // This would throw - we didn't implement deleteUser
+   *   // yield* userService.deleteUser("123") // UnimplementedError
+   * }).pipe(
+   *   Effect.provide(testUserLayer)
+   * )
+   * ```
+   *
+   * @since 4.0.0
+   * @category Testing
+   */
+  <I, S extends object>(
+    service: ServiceMap.Key<I, S>,
+    implementation: Types.NoInfer<PartialEffectful<S>>
+  ): Layer<I>
+} = function() {
+  if (arguments.length === 1) {
+    return (implementation: any) => mockImpl(arguments[0], implementation)
+  }
+  return mockImpl(arguments[0], arguments[1])
+} as any
+
+const mockImpl = <I, S extends object>(service: ServiceMap.Key<I, S>, implementation: PartialEffectful<S>): Layer<I> =>
+  succeed(service)(
+    new Proxy({ ...implementation as object } as S, {
+      get(target, prop, _receiver) {
+        if (prop in target) {
+          return target[prop as keyof S]
+        }
+        const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
+        const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
+        error.name = "UnimplementedError"
+        return makeUnimplemented(error)
+      },
+      has: constTrue
+    })
+  )
 
 const makeUnimplemented = (error: globalThis.Error) => {
   const dead = internalEffect.die(error)

package/src/Number.ts

@@ -6,6 +6,7 @@
  */
 import * as Equ from "./Equivalence.ts"
 import { dual } from "./Function.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Ordering } from "./Ordering.ts"
 import * as predicate from "./Predicate.ts"
@@ -191,15 +192,15 @@ export const subtract: {
 /**
  * Provides a division operation on `number`s.
  *
- * Returns `undefined` if the divisor is `0`.
+ * Returns `Option.none()` if the divisor is `0`.
  *
  * **Example**
  *
  * ```ts
  * import { Number } from "effect"
  *
- * Number.divide(6, 3) // 2
- * Number.divide(6, 0) // undefined
+ * Number.divide(6, 3) // Option.some(2)
+ * Number.divide(6, 0) // Option.none()
  * ```
  *
  * @category math
@@ -209,42 +210,102 @@ export const divide: {
   /**
    * Provides a division operation on `number`s.
    *
-   * Returns `undefined` if the divisor is `0`.
+   * Returns `Option.none()` if the divisor is `0`.
    *
    * **Example**
    *
    * ```ts
    * import { Number } from "effect"
    *
-   * Number.divide(6, 3) // 2
-   * Number.divide(6, 0) // undefined
+   * Number.divide(6, 3) // Option.some(2)
+   * Number.divide(6, 0) // Option.none()
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (that: number): (self: number) => number | undefined
+  (that: number): (self: number) => Option.Option<number>
   /**
    * Provides a division operation on `number`s.
    *
-   * Returns `undefined` if the divisor is `0`.
+   * Returns `Option.none()` if the divisor is `0`.
    *
    * **Example**
    *
    * ```ts
    * import { Number } from "effect"
    *
-   * Number.divide(6, 3) // 2
-   * Number.divide(6, 0) // undefined
+   * Number.divide(6, 3) // Option.some(2)
+   * Number.divide(6, 0) // Option.none()
    * ```
    *
    * @category math
    * @since 2.0.0
    */
-  (self: number, that: number): number | undefined
+  (self: number, that: number): Option.Option<number>
 } = dual(
   2,
-  (self: number, that: number): number | undefined => that === 0 ? undefined : self / that
+  (self: number, that: number): Option.Option<number> => that === 0 ? Option.none() : Option.some(self / that)
+)
+
+/**
+ * Provides an unsafe division operation on `number`s.
+ *
+ * Throws a `RangeError` if the divisor is `0`.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Number } from "effect"
+ *
+ * Number.divideUnsafe(6, 3) // 2
+ * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+ * ```
+ *
+ * @category math
+ * @since 2.0.0
+ */
+export const divideUnsafe: {
+  /**
+   * Provides an unsafe division operation on `number`s.
+   *
+   * Throws a `RangeError` if the divisor is `0`.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Number } from "effect"
+   *
+   * Number.divideUnsafe(6, 3) // 2
+   * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+   * ```
+   *
+   * @category math
+   * @since 2.0.0
+   */
+  (that: number): (self: number) => number
+  /**
+   * Provides an unsafe division operation on `number`s.
+   *
+   * Throws a `RangeError` if the divisor is `0`.
+   *
+   * **Example**
+   *
+   * ```ts
+   * import { Number } from "effect"
+   *
+   * Number.divideUnsafe(6, 3) // 2
+   * Number.divideUnsafe(6, 0) // throws RangeError("Division by zero")
+   * ```
+   *
+   * @category math
+   * @since 2.0.0
+   */
+  (self: number, that: number): number
+} = dual(
+  2,
+  (self: number, that: number): number =>
+    Option.getOrThrowWith(divide(self, that), () => new RangeError("Division by zero"))
 )
 
 /**
@@ -934,34 +995,32 @@ export const nextPow2 = (n: number): number => {
  * ```ts
  * import { Number } from "effect"
  *
- * Number.parse("42") // 42
- * Number.parse("3.14") // 3.14
- * Number.parse("NaN") // NaN
- * Number.parse("Infinity") // Infinity
- * Number.parse("-Infinity") // -Infinity
- * Number.parse("not a number") // undefined
+ * Number.parse("42") // Option.some(42)
+ * Number.parse("3.14") // Option.some(3.14)
+ * Number.parse("NaN") // Option.some(NaN)
+ * Number.parse("Infinity") // Option.some(Infinity)
+ * Number.parse("-Infinity") // Option.some(-Infinity)
+ * Number.parse("not a number") // Option.none()
  * ```
  *
  * @category constructors
  * @since 2.0.0
  */
-export const parse = (s: string): number | undefined => {
+export const parse = (s: string): Option.Option<number> => {
   if (s === "NaN") {
-    return NaN
+    return Option.some(NaN)
   }
   if (s === "Infinity") {
-    return Infinity
+    return Option.some(Infinity)
   }
   if (s === "-Infinity") {
-    return -Infinity
+    return Option.some(-Infinity)
   }
   if (s.trim() === "") {
-    return undefined
+    return Option.none()
   }
   const n = Number(s)
-  return Number.isNaN(n) ?
-    undefined
-    : n
+  return Number.isNaN(n) ? Option.none() : Option.some(n)
 }
 
 /**

package/src/Option.ts

@@ -156,6 +156,7 @@ export type Option<A> = None<A> | Some<A>
 export interface None<out A> extends Pipeable, Inspectable, Yieldable<Option<A>, A, NoSuchElementError> {
   readonly _tag: "None"
   readonly _op: "None"
+  readonly valueOrUndefined: undefined
   readonly [TypeId]: {
     readonly _A: Covariant<A>
   }
@@ -189,6 +190,7 @@ export interface Some<out A> extends Pipeable, Inspectable, Yieldable<Option<A>,
   readonly _tag: "Some"
   readonly _op: "Some"
   readonly value: A
+  readonly valueOrUndefined: A
   readonly [TypeId]: {
     readonly _A: Covariant<A>
   }