effect 4.0.0-beta.31 → 4.0.0-beta.32

package/src/Chunk.ts

@@ -88,7 +88,6 @@ import { hasProperty, type Predicate, type Refinement } from "./Predicate.ts"
 import * as R from "./Result.ts"
 import type { Result } from "./Result.ts"
 import type { Covariant, NoInfer } from "./Types.ts"
-import * as UndefinedOr from "./UndefinedOr.ts"
 
 const TypeId = "~effect/collections/Chunk"
 
@@ -3467,7 +3466,7 @@ export const splitWhere: {
  * @since 2.0.0
  * @category elements
  */
-export const tail = <A>(self: Chunk<A>): Chunk<A> | undefined => self.length > 0 ? drop(self, 1) : undefined
+export const tail = <A>(self: Chunk<A>): O.Option<Chunk<A>> => self.length > 0 ? O.some(drop(self, 1)) : O.none()
 
 /**
  * Returns every elements after the first.
@@ -4096,15 +4095,15 @@ export const remove: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4)
  * const result = Chunk.modify(chunk, 1, (n) => n * 10)
- * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+ * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
- * console.log(outOfBounds === undefined) // true
+ * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+ * console.log(outOfBounds) // Option.none()
  *
  * // Negative index returns None
- * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
- * console.log(negative === undefined) // true
+ * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+ * console.log(negative) // Option.none()
  * ```
  *
  * @category elements
@@ -4121,21 +4120,21 @@ export const modify: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4)
    * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-   * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+   * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
    *
    * // Index out of bounds returns None
-   * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
-   * console.log(outOfBounds === undefined) // true
+   * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+   * console.log(outOfBounds) // Option.none()
    *
    * // Negative index returns None
-   * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
-   * console.log(negative === undefined) // true
+   * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+   * console.log(negative) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B> | undefined
+  <A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => O.Option<Chunk<A | B>>
   /**
    * Applies a function to the element at the specified index, creating a new `Chunk`,
    * or returns `None` if the index is out of bounds.
@@ -4146,25 +4145,25 @@ export const modify: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4)
    * const result = Chunk.modify(chunk, 1, (n) => n * 10)
-   * console.log(result) // { _id: 'Chunk', values: [ 1, 20, 3, 4 ] }
+   * console.log(result) // Option.some(Chunk.make(1, 20, 3, 4))
    *
    * // Index out of bounds returns None
-   * const outOfBounds = chunk?.pipe(Chunk.modify(10, (n) => n * 10))
-   * console.log(outOfBounds === undefined) // true
+   * const outOfBounds = chunk.pipe(Chunk.modify(10, (n) => n * 10))
+   * console.log(outOfBounds) // Option.none()
    *
    * // Negative index returns None
-   * const negative = chunk?.pipe(Chunk.modify(-1, (n) => n * 10))
-   * console.log(negative === undefined) // true
+   * const negative = chunk.pipe(Chunk.modify(-1, (n) => n * 10))
+   * console.log(negative) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B> | undefined
+  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): O.Option<Chunk<A | B>>
 } = dual(
   3,
-  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B> | undefined =>
-    UndefinedOr.map(RA.modify(toReadonlyArray(self), i, f), fromArrayUnsafe)
+  <A, B>(self: Chunk<A>, i: number, f: (a: A) => B): O.Option<Chunk<A | B>> =>
+    pipe(RA.modify(toReadonlyArray(self), i, f), O.map(fromArrayUnsafe))
 )
 
 /**
@@ -4177,15 +4176,15 @@ export const modify: {
  *
  * const chunk = Chunk.make("a", "b", "c", "d")
  * const result = Chunk.replace(chunk, 1, "X")
- * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+ * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
  *
  * // Index out of bounds returns None
- * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
- * console.log(outOfBounds === undefined) // true
+ * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+ * console.log(outOfBounds) // Option.none()
  *
  * // Negative index returns None
- * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
- * console.log(negative === undefined) // true
+ * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+ * console.log(negative) // Option.none()
  * ```
  *
  * @category elements
@@ -4202,21 +4201,21 @@ export const replace: {
    *
    * const chunk = Chunk.make("a", "b", "c", "d")
    * const result = Chunk.replace(chunk, 1, "X")
-   * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+   * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
    *
    * // Index out of bounds returns None
-   * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
-   * console.log(outOfBounds === undefined) // true
+   * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+   * console.log(outOfBounds) // Option.none()
    *
    * // Negative index returns None
-   * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
-   * console.log(negative === undefined) // true
+   * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+   * console.log(negative) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A> | undefined
+  <B>(i: number, b: B): <A>(self: Chunk<A>) => O.Option<Chunk<B | A>>
   /**
    * Change the element at the specified index, creating a new `Chunk`,
    * or returns `None` if the index is out of bounds.
@@ -4227,22 +4226,22 @@ export const replace: {
    *
    * const chunk = Chunk.make("a", "b", "c", "d")
    * const result = Chunk.replace(chunk, 1, "X")
-   * console.log(result) // { _id: 'Chunk', values: [ 'a', 'X', 'c', 'd' ] }
+   * console.log(result) // Option.some(Chunk.make("a", "X", "c", "d"))
    *
    * // Index out of bounds returns None
-   * const outOfBounds = chunk?.pipe(Chunk.replace(10, "Y"))
-   * console.log(outOfBounds === undefined) // true
+   * const outOfBounds = chunk.pipe(Chunk.replace(10, "Y"))
+   * console.log(outOfBounds) // Option.none()
    *
    * // Negative index returns None
-   * const negative = chunk?.pipe(Chunk.replace(-1, "Z"))
-   * console.log(negative === undefined) // true
+   * const negative = chunk.pipe(Chunk.replace(-1, "Z"))
+   * console.log(negative) // Option.none()
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A> | undefined
-} = dual(3, <A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A> | undefined => modify(self, i, () => b))
+  <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>>
+} = dual(3, <A, B>(self: Chunk<A>, i: number, b: B): O.Option<Chunk<B | A>> => modify(self, i, () => b))
 
 /**
  * Return a Chunk of length n with element i initialized with f(i).
@@ -4603,15 +4602,15 @@ export const findFirst: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
  * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
- * console.log(result) // 3
+ * console.log(result) // Option.some(3)
  *
  * // No match found
  * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  *
  * // Find first even number
  * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
- * console.log(firstEven) // 1
+ * console.log(firstEven) // Option.some(1)
  * ```
  *
  * @category elements
@@ -4627,21 +4626,21 @@ export const findFirstIndex: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4, 5)
    * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-   * console.log(result) // 3
+   * console.log(result) // Option.some(3)
    *
    * // No match found
    * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-   * console.log(notFound) // undefined
+   * console.log(notFound) // Option.none()
    *
    * // Find first even number
    * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-   * console.log(firstEven) // 1
+   * console.log(firstEven) // Option.some(1)
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => number | undefined
+  <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>
   /**
    * Return the first index for which a predicate holds.
    *
@@ -4651,22 +4650,25 @@ export const findFirstIndex: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4, 5)
    * const result = Chunk.findFirstIndex(chunk, (n) => n > 3)
-   * console.log(result) // 3
+   * console.log(result) // Option.some(3)
    *
    * // No match found
    * const notFound = Chunk.findFirstIndex(chunk, (n) => n > 10)
-   * console.log(notFound) // undefined
+   * console.log(notFound) // Option.none()
    *
    * // Find first even number
    * const firstEven = Chunk.findFirstIndex(chunk, (n) => n % 2 === 0)
-   * console.log(firstEven) // 1
+   * console.log(firstEven) // Option.some(1)
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Chunk<A>, predicate: Predicate<A>): number | undefined
-} = RA.findFirstIndex
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number> => RA.findFirstIndex(self, predicate)
+)
 
 /**
  * Find the last element for which a predicate holds.
@@ -4809,15 +4811,15 @@ export const findLast: {
  *
  * const chunk = Chunk.make(1, 2, 3, 4, 5)
  * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
- * console.log(result) // 2
+ * console.log(result) // Option.some(2)
  *
  * // No match found
  * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
- * console.log(notFound) // undefined
+ * console.log(notFound) // Option.none()
  *
  * // Find last even number index
  * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
- * console.log(lastEven) // 3
+ * console.log(lastEven) // Option.some(3)
  * ```
  *
  * @category elements
@@ -4833,21 +4835,21 @@ export const findLastIndex: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4, 5)
    * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-   * console.log(result) // 2
+   * console.log(result) // Option.some(2)
    *
    * // No match found
    * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-   * console.log(notFound) // undefined
+   * console.log(notFound) // Option.none()
    *
    * // Find last even number index
    * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-   * console.log(lastEven) // 3
+   * console.log(lastEven) // Option.some(3)
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A>(predicate: Predicate<A>): (self: Chunk<A>) => number | undefined
+  <A>(predicate: Predicate<A>): (self: Chunk<A>) => O.Option<number>
   /**
    * Return the last index for which a predicate holds.
    *
@@ -4857,22 +4859,25 @@ export const findLastIndex: {
    *
    * const chunk = Chunk.make(1, 2, 3, 4, 5)
    * const result = Chunk.findLastIndex(chunk, (n) => n < 4)
-   * console.log(result) // 2
+   * console.log(result) // Option.some(2)
    *
    * // No match found
    * const notFound = Chunk.findLastIndex(chunk, (n) => n > 10)
-   * console.log(notFound) // undefined
+   * console.log(notFound) // Option.none()
    *
    * // Find last even number index
    * const lastEven = Chunk.findLastIndex(chunk, (n) => n % 2 === 0)
-   * console.log(lastEven) // 3
+   * console.log(lastEven) // Option.some(3)
    * ```
    *
    * @category elements
    * @since 2.0.0
    */
-  <A>(self: Chunk<A>, predicate: Predicate<A>): number | undefined
-} = RA.findLastIndex
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number>
+} = dual(
+  2,
+  <A>(self: Chunk<A>, predicate: Predicate<A>): O.Option<number> => RA.findLastIndex(self, predicate)
+)
 
 /**
  * Check if a predicate holds true for every `Chunk` element.

package/src/Config.ts

@@ -950,7 +950,10 @@ export const Boolean = Schema.Literals([...TrueValues.literals, ...FalseValues.l
 export const Duration = Schema.String.pipe(Schema.decodeTo(Schema.Duration, {
   decode: Getter.transformOrFail((s) => {
     const d = Duration_.fromInput(s as any)
-    return d ? Effect.succeed(d) : Effect.fail(new Issue.InvalidValue(Option.some(s)))
+    return Option.match(d, {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s))),
+      onSome: Effect.succeed
+    })
   }),
   encode: Getter.forbidden(() => "Encoding Duration is not supported")
 }))

package/src/Cron.ts

@@ -12,12 +12,12 @@ import * as Hash from "./Hash.ts"
 import { type Inspectable, NodeInspectSymbol } from "./Inspectable.ts"
 import * as dateTime from "./internal/dateTime.ts"
 import * as N from "./Number.ts"
+import * as Option from "./Option.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Result from "./Result.ts"
 import * as String from "./String.ts"
 import type { Mutable } from "./Types.ts"
-import * as UndefinedOr from "./UndefinedOr.ts"
 
 const TypeId = "~effect/time/Cron"
 
@@ -83,7 +83,7 @@ const TypeId = "~effect/time/Cron"
  */
 export interface Cron extends Pipeable, Equal.Equal, Inspectable {
   readonly [TypeId]: typeof TypeId
-  readonly tz: DateTime.TimeZone | undefined
+  readonly tz: Option.Option<DateTime.TimeZone>
   readonly seconds: ReadonlySet<number>
   readonly minutes: ReadonlySet<number>
   readonly hours: ReadonlySet<number>
@@ -307,7 +307,7 @@ export const make = (values: {
   o.days = new Set(Arr.sort(values.days, N.Order))
   o.months = new Set(Arr.sort(values.months, N.Order))
   o.weekdays = new Set(Arr.sort(values.weekdays, N.Order))
-  o.tz = values.tz
+  o.tz = Option.fromUndefinedOr(values.tz)
 
   const seconds = Array.from(o.seconds)
   const minutes = Array.from(o.minutes)
@@ -379,15 +379,11 @@ const CronParseErrorTypeId = "~effect/time/Cron/CronParseError"
  * @since 4.0.0
  * @category models
  */
-/**
- * @category Models
- * @since 4.0.0
- */
 export class CronParseError extends Data.TaggedError("CronParseError")<{
   readonly message: string
   readonly input?: string
 }> {
-  readonly [CronParseErrorTypeId] = CronParseErrorTypeId
+  readonly [CronParseErrorTypeId]: typeof CronParseErrorTypeId = CronParseErrorTypeId
 }
 
 /**
@@ -456,11 +452,10 @@ export const parse = (cron: string, tz?: DateTime.TimeZone | string): Result.Res
   const [seconds, minutes, hours, days, months, weekdays] = segments
   const zone = tz === undefined || dateTime.isTimeZone(tz) ?
     Result.succeed(tz) :
-    UndefinedOr.match(dateTime.zoneFromString(tz), {
-      onUndefined: () =>
-        Result.fail(new CronParseError({ message: `Invalid time zone in cron expression`, input: tz })),
-      onDefined: (zone) => Result.succeed(zone)
-    })
+    Result.fromOption(
+      dateTime.zoneFromString(tz),
+      () => new CronParseError({ message: `Invalid time zone in cron expression`, input: tz })
+    )
 
   return Result.all({
     tz: zone,
@@ -528,7 +523,7 @@ export const parseUnsafe = (cron: string, tz?: DateTime.TimeZone | string): Cron
  */
 export const match = (cron: Cron, date: DateTime.DateTime.Input): boolean => {
   const parts = dateTime.makeZonedUnsafe(date, {
-    timeZone: cron.tz
+    timeZone: Option.getOrUndefined(cron.tz)
   }).pipe(dateTime.toParts)
 
   if (cron.seconds.size !== 0 && !cron.seconds.has(parts.second)) {
@@ -592,7 +587,7 @@ const daysInMonth = (date: Date): number =>
  * @category utils
  */
 export const next = (cron: Cron, now?: DateTime.DateTime.Input): Date => {
-  const tz = cron.tz
+  const tz = Option.getOrUndefined(cron.tz)
   const zoned = dateTime.makeZonedUnsafe(now ?? new Date(), {
     timeZone: tz
   })

package/src/DateTime.ts

@@ -10,6 +10,7 @@ import type { Inspectable } from "./Inspectable.ts"
 import * as Internal from "./internal/dateTime.ts"
 import { provideService } from "./internal/effect.ts"
 import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
 import type * as order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as ServiceMap from "./ServiceMap.ts"
@@ -557,7 +558,7 @@ export const makeZoned: (
     readonly adjustForTimeZone?: boolean | undefined
     readonly disambiguation?: Disambiguation | undefined
   }
-) => Zoned | undefined = Internal.makeZoned
+) => Option.Option<Zoned> = Internal.makeZoned
 
 /**
  * Create a `DateTime` from one of the following:
@@ -586,7 +587,7 @@ export const makeZoned: (
  * DateTime.make("2024-01-01")
  * ```
  */
-export const make: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone<A> | undefined = Internal.make
+export const make: <A extends DateTime.Input>(input: A) => Option.Option<DateTime.PreserveZone<A>> = Internal.make
 
 /**
  * Create a `DateTime.Zoned` from a string.
@@ -600,19 +601,19 @@ export const make: <A extends DateTime.Input>(input: A) => DateTime.PreserveZone
  * const result1 = DateTime.makeZonedFromString(
  *   "2024-01-01T12:00:00+02:00[Europe/Berlin]"
  * )
- * console.log(result1 !== undefined) // true
+ * console.log(result1._tag === "Some") // true
  *
  * const result2 = DateTime.makeZonedFromString("2024-01-01T12:00:00Z")
- * console.log(result2 !== undefined) // true
+ * console.log(result2._tag === "Some") // true
  *
  * const invalid = DateTime.makeZonedFromString("invalid")
- * console.log(invalid === undefined) // true
+ * console.log(invalid._tag === "None") // true
  * ```
  *
  * @since 3.6.0
  * @category constructors
  */
-export const makeZonedFromString: (input: string) => Zoned | undefined = Internal.makeZonedFromString
+export const makeZonedFromString: (input: string) => Option.Option<Zoned> = Internal.makeZonedFromString
 
 /**
  * Get the current time using the `Clock` service and convert it to a `DateTime`.
@@ -892,16 +893,16 @@ export const zoneMakeOffset: (offset: number) => TimeZone.Offset = Internal.zone
  * import { DateTime } from "effect"
  *
  * const validZone = DateTime.zoneMakeNamed("Europe/London")
- * console.log(validZone !== undefined) // true
+ * console.log(validZone._tag === "Some") // true
  *
  * const invalidZone = DateTime.zoneMakeNamed("Invalid/Zone")
- * console.log(invalidZone === undefined) // true
+ * console.log(invalidZone._tag === "None") // true
  * ```
  *
  * @category time zones
  * @since 3.6.0
  */
-export const zoneMakeNamed: (zoneId: string) => TimeZone.Named | undefined = Internal.zoneMakeNamed
+export const zoneMakeNamed: (zoneId: string) => Option.Option<TimeZone.Named> = Internal.zoneMakeNamed
 
 /**
  * Create a named time zone from a IANA time zone identifier.
@@ -960,15 +961,15 @@ export const zoneMakeLocal: () => TimeZone.Named = Internal.zoneMakeLocal
  * const offsetZone = DateTime.zoneFromString("+03:00")
  * const invalid = DateTime.zoneFromString("invalid")
  *
- * console.log(namedZone !== undefined) // true
- * console.log(offsetZone !== undefined) // true
- * console.log(invalid === undefined) // true
+ * console.log(namedZone._tag === "Some") // true
+ * console.log(offsetZone._tag === "Some") // true
+ * console.log(invalid._tag === "None") // true
  * ```
  *
  * @category time zones
  * @since 3.6.0
  */
-export const zoneFromString: (zone: string) => TimeZone | undefined = Internal.zoneFromString
+export const zoneFromString: (zone: string) => Option.Option<TimeZone> = Internal.zoneFromString
 
 /**
  * Format a `TimeZone` as a string.
@@ -1029,7 +1030,7 @@ export const setZoneNamed: {
      readonly adjustForTimeZone?: boolean | undefined
      readonly disambiguation?: Disambiguation | undefined
    }
-  ): (self: DateTime) => Zoned | undefined
+  ): (self: DateTime) => Option.Option<Zoned>
   /**
    * Set the time zone of a `DateTime` from an IANA time zone identifier. If the
    * time zone is invalid, `None` will be returned.
@@ -1054,7 +1055,7 @@ export const setZoneNamed: {
      readonly adjustForTimeZone?: boolean | undefined
      readonly disambiguation?: Disambiguation | undefined
    }
-  ): Zoned | undefined
+  ): Option.Option<Zoned>
 } = Internal.setZoneNamed
 
 /**

package/src/Deferred.ts

@@ -72,6 +72,7 @@ import type * as Exit from "./Exit.ts"
 import { dual, identity, type LazyArg } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internalEffect from "./internal/effect.ts"
+import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import type * as Types from "./Types.ts"
@@ -973,8 +974,9 @@ export const isDone = <A, E>(self: Deferred<A, E>): Effect<boolean> => internalE
 export const isDoneUnsafe = <A, E>(self: Deferred<A, E>): boolean => self.effect !== undefined
 
 /**
- * Returns a `Effect<A, E, R>` from the `Deferred` if this `Deferred` has
- * already been completed, `undefined` otherwise.
+ * Returns the current completion effect as an `Option`. This returns
+ * `Option.some(effect)` when the `Deferred` is completed, `Option.none()`
+ * otherwise.
  *
  * @example
  * ```ts
@@ -983,19 +985,19 @@ export const isDoneUnsafe = <A, E>(self: Deferred<A, E>): boolean => self.effect
  * const program = Effect.gen(function*() {
  *   const deferred = yield* Deferred.make<number>()
  *   const beforeCompletion = yield* Deferred.poll(deferred)
- *   console.log(beforeCompletion === undefined) // true
+ *   console.log(beforeCompletion._tag === "None") // true
  *
  *   yield* Deferred.succeed(deferred, 42)
  *   const afterCompletion = yield* Deferred.poll(deferred)
- *   console.log(afterCompletion !== undefined) // true
+ *   console.log(afterCompletion._tag === "Some") // true
  * })
  * ```
  *
  * @since 2.0.0
  * @category getters
  */
-export function poll<A, E>(self: Deferred<A, E>): Effect<Effect<A, E> | undefined> {
-  return internalEffect.sync(() => self.effect)
+export function poll<A, E>(self: Deferred<A, E>): Effect<Option.Option<Effect<A, E>>> {
+  return internalEffect.sync(() => Option.fromUndefinedOr(self.effect))
 }
 
 /**