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

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.
@@ -2158,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.
@@ -2178,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.
@@ -2201,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.
@@ -2224,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()
   }
 )

package/src/Scheduler.ts

@@ -19,8 +19,17 @@ import * as ServiceMap from "./ServiceMap.ts"
  */
 export interface Scheduler {
   readonly executionMode: "sync" | "async"
-  readonly scheduleTask: (task: () => void, priority: number) => void
-  readonly shouldYield: (fiber: Fiber.Fiber<unknown, unknown>) => boolean
+  shouldYield(fiber: Fiber.Fiber<unknown, unknown>): boolean
+  makeDispatcher(): SchedulerDispatcher
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface SchedulerDispatcher {
+  scheduleTask(task: () => void, priority: number): void
+  flush(): void
 }
 
 /**
@@ -82,40 +91,10 @@ class PriorityBuckets {
  * - Automatic yielding based on operation count
  * - Optimized for high-throughput scenarios
  *
- * @example
- * ```ts
- * import { MixedScheduler } from "effect/Scheduler"
- *
- * // Create a mixed scheduler with async execution (default)
- * const asyncScheduler = new MixedScheduler("async")
- *
- * // Create a mixed scheduler with sync execution
- * const syncScheduler = new MixedScheduler("sync")
- *
- * // Schedule tasks with different priorities
- * asyncScheduler.scheduleTask(() => console.log("High priority task"), 10)
- * asyncScheduler.scheduleTask(() => console.log("Normal priority task"), 0)
- * asyncScheduler.scheduleTask(() => console.log("Low priority task"), -1)
- *
- * // For sync scheduler, you can flush tasks immediately
- * syncScheduler.scheduleTask(() => console.log("Task 1"), 0)
- * syncScheduler.scheduleTask(() => console.log("Task 2"), 0)
- *
- * // Force flush all pending tasks in sync mode
- * syncScheduler.flush()
- * // Output: "Task 1", "Task 2"
- *
- * // Check execution mode
- * console.log(asyncScheduler.executionMode) // "async"
- * console.log(syncScheduler.executionMode) // "sync"
- * ```
- *
  * @since 2.0.0
  * @category schedulers
  */
 export class MixedScheduler implements Scheduler {
-  private tasks = new PriorityBuckets()
-  private running: (() => void) | undefined = undefined
   readonly executionMode: "sync" | "async"
   readonly setImmediate: (f: () => void) => () => void
 
@@ -127,6 +106,32 @@ export class MixedScheduler implements Scheduler {
     this.setImmediate = setImmediateFn
   }
 
+  /**
+   * @since 2.0.0
+   */
+  shouldYield(fiber: Fiber.Fiber<unknown, unknown>) {
+    return fiber.currentOpCount >= fiber.maxOpsBeforeYield
+  }
+
+  /**
+   * @since 2.0.0
+   */
+  makeDispatcher() {
+    return new MixedSchedulerDispatcher(this.setImmediate)
+  }
+}
+
+class MixedSchedulerDispatcher implements SchedulerDispatcher {
+  private tasks = new PriorityBuckets()
+  private running: (() => void) | undefined = undefined
+  readonly setImmediate: (f: () => void) => () => void
+
+  constructor(
+    setImmediateFn: (f: () => void) => () => void = setImmediate
+  ) {
+    this.setImmediate = setImmediateFn
+  }
+
   /**
    * @since 2.0.0
    */
@@ -158,13 +163,6 @@ export class MixedScheduler implements Scheduler {
     }
   }
 
-  /**
-   * @since 2.0.0
-   */
-  shouldYield(fiber: Fiber.Fiber<unknown, unknown>) {
-    return fiber.currentOpCount >= fiber.maxOpsBeforeYield
-  }
-
   /**
    * @since 2.0.0
    */
@@ -187,93 +185,6 @@ export class MixedScheduler implements Scheduler {
  * The default value is 2048 operations, which provides a good balance between
  * performance and fairness in concurrent execution.
  *
- * @example
- * ```ts
- * import { Effect } from "effect"
- * import { MaxOpsBeforeYield } from "effect/Scheduler"
- *
- * // Configure a fiber to yield more frequently
- * const program = Effect.gen(function*() {
- *   // Get current max ops setting (default is 2048)
- *   const currentMax = yield* MaxOpsBeforeYield
- *   yield* Effect.log(`Default max ops before yield: ${currentMax}`)
- *
- *   // Run with reduced max ops for more frequent yielding
- *   return yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const maxOps = yield* MaxOpsBeforeYield
- *       yield* Effect.log(`Max ops before yield: ${maxOps}`)
- *
- *       // Run a compute-intensive task that will yield frequently
- *       let result = 0
- *       for (let i = 0; i < 10000; i++) {
- *         result += i
- *         // This will cause yielding every 100 operations
- *         yield* Effect.sync(() => result)
- *       }
- *       return result
- *     }),
- *     MaxOpsBeforeYield,
- *     100
- *   )
- * })
- *
- * // Configure for high-performance scenarios
- * const highPerformanceProgram = Effect.gen(function*() {
- *   // Run with increased max ops for better performance (less yielding)
- *   return yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const maxOps = yield* MaxOpsBeforeYield
- *       yield* Effect.log(`High-performance max ops: ${maxOps}`)
- *
- *       // Run multiple concurrent tasks
- *       const tasks = Array.from(
- *         { length: 100 },
- *         (_, i) =>
- *           Effect.gen(function*() {
- *             yield* Effect.sleep(`${i * 10} millis`)
- *             return `Task ${i} completed`
- *           })
- *       )
- *
- *       return yield* Effect.all(tasks, { concurrency: "unbounded" })
- *     }),
- *     MaxOpsBeforeYield,
- *     10000
- *   )
- * })
- *
- * // Configure for fair scheduling
- * const fairSchedulingProgram = Effect.gen(function*() {
- *   // Run with lower max ops for more frequent yielding
- *   return yield* Effect.provideService(
- *     Effect.gen(function*() {
- *       const maxOps = yield* MaxOpsBeforeYield
- *       yield* Effect.log(`Fair scheduling max ops: ${maxOps}`)
- *
- *       const longRunningTask = Effect.gen(function*() {
- *         for (let i = 0; i < 1000; i++) {
- *           yield* Effect.sync(() => Math.random())
- *         }
- *         return "Long task completed"
- *       })
- *
- *       const quickTask = Effect.gen(function*() {
- *         yield* Effect.sleep("10 millis")
- *         return "Quick task completed"
- *       })
- *
- *       // Both tasks will execute fairly due to frequent yielding
- *       return yield* Effect.all([longRunningTask, quickTask], {
- *         concurrency: "unbounded"
- *       })
- *     }),
- *     MaxOpsBeforeYield,
- *     50
- *   )
- * })
- * ```
- *
  * @since 4.0.0
  * @category references
  */

package/src/Schema.ts

@@ -968,7 +968,7 @@ export function toStandardSchemaV1<
       }),
       { scheduler }
     )
-    scheduler.flush()
+    fiber.currentDispatcher?.flush()
     const exit = fiber.pollUnsafe()
     if (exit) {
       return makeStandardResult(exit)
@@ -6998,6 +6998,54 @@ export function OptionFromOptional<S extends Top>(schema: S): OptionFromOptional
   ))
 }
 
+/**
+ * Schema type for {@link OptionFromOptionalNullOr}.
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export interface OptionFromOptionalNullOr<S extends Top> extends decodeTo<Option<toType<S>>, optional<NullOr<S>>> {}
+
+/**
+ * Decodes an optional or `null` or `undefined` value `A` to a required `Option<A>`
+ * value.
+ *
+ * Decoding:
+ * - a missing key is decoded as `None`
+ * - a present key with an `undefined` value is decoded as `None`
+ * - a present key with a `null` value is decoded as `None`
+ * - all other values are decoded as `Some`
+ *
+ * Encoding (controlled by `options.onNoneEncoding`):
+ * - `"omit"` (default): `None` is encoded as a missing key
+ * - `null`: `None` is encoded as `null`
+ * - `undefined`: `None` is encoded as `undefined`
+ * - `Some` is always encoded as the value
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export function OptionFromOptionalNullOr<S extends Top>(
+  schema: S,
+  options?: {
+    readonly onNoneEncoding: "omit" | null | undefined
+  }
+): OptionFromOptionalNullOr<S> {
+  const onNoneEncoding = options === undefined ? "omit" : options.onNoneEncoding
+  const noneValue = onNoneEncoding === null
+    ? null as S["Type"] | null | undefined
+    : undefined as S["Type"] | null | undefined
+  return optional(NullOr(schema)).pipe(decodeTo(
+    Option(toType(schema)),
+    Transformation.transformOptional<Option_.Option<S["Type"]>, S["Type"] | null | undefined>({
+      decode: (oe) => oe.pipe(Option_.filter(Predicate.isNotNullish), Option_.some),
+      encode: onNoneEncoding === "omit"
+        ? Option_.flatten
+        : (ot) => Option_.some(Option_.getOrElse(Option_.flatten(ot), () => noneValue))
+    })
+  ))
+}
+
 /**
  * Schema for the `Result<A, E>` type, representing a computation that either
  * succeeds with `A` or fails with `E`.

package/src/SchemaGetter.ts

@@ -1482,10 +1482,10 @@ export function decodeHexString<E extends string>(): Getter<string, E> {
  */
 export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Getter<DateTime.Utc, E> {
   return transformOrFail((input) => {
-    const dt = DateTime.make(input)
-    return dt
-      ? Effect.succeed(DateTime.toUtc(dt))
-      : Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" }))
+    return Option.match(DateTime.make(input), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" })),
+      onSome: (dt) => Effect.succeed(DateTime.toUtc(dt))
+    })
   })
 }
 

package/src/SchemaTransformation.ts

@@ -907,15 +907,14 @@ export const bigintFromString = new Transformation(
  */
 export const durationFromNanos: Transformation<Duration.Duration, bigint> = transformOrFail({
   decode: (i) => Effect.succeed(Duration.nanos(i)),
-  encode: (a) => {
-    const nanos = Duration.toNanos(a)
-    if (Predicate.isUndefined(nanos)) {
-      return Effect.fail(
-        new Issue.InvalidValue(Option.some(a), { message: `Unable to encode ${a} into a bigint` })
-      )
-    }
-    return Effect.succeed(nanos)
-  }
+  encode: (a) =>
+    Option.match(Duration.toNanos(a), {
+      onNone: () =>
+        Effect.fail(
+          new Issue.InvalidValue(Option.some(a), { message: `Unable to encode ${a} into a bigint` })
+        ),
+      onSome: (nanos) => Effect.succeed(nanos)
+    })
 })
 
 /**
@@ -1239,9 +1238,9 @@ export const bigDecimalFromString: Transformation<BigDecimal.BigDecimal, string>
 >({
   decode: (s) => {
     const result = BigDecimal.fromString(s)
-    return result === undefined
+    return Option.isNone(result)
       ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid BigDecimal string: ${s}` }))
-      : Effect.succeed(result)
+      : Effect.succeed(result.value)
   },
   encode: (bd) => Effect.succeed(BigDecimal.format(bd))
 })
@@ -1394,10 +1393,10 @@ export const timeZoneNamedFromString: Transformation<DateTime.TimeZone.Named, st
   string
 >({
   decode: (s) => {
-    const result = DateTime.zoneMakeNamed(s)
-    return result === undefined
-      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid IANA time zone: ${s}` }))
-      : Effect.succeed(result)
+    return Option.match(DateTime.zoneMakeNamed(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid IANA time zone: ${s}` })),
+      onSome: Effect.succeed
+    })
   },
   encode: (tz) => Effect.succeed(tz.id)
 })
@@ -1410,10 +1409,10 @@ export const timeZoneFromString: Transformation<DateTime.TimeZone, string> = tra
   string
 >({
   decode: (s) => {
-    const result = DateTime.zoneFromString(s)
-    return result === undefined
-      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid time zone: ${s}` }))
-      : Effect.succeed(result)
+    return Option.match(DateTime.zoneFromString(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid time zone: ${s}` })),
+      onSome: Effect.succeed
+    })
   },
   encode: (tz) => Effect.succeed(DateTime.zoneToString(tz))
 })
@@ -1426,10 +1425,10 @@ export const dateTimeUtcFromString: Transformation<DateTime.Utc, string> = trans
   string
 >({
   decode: (s) => {
-    const result = DateTime.make(s)
-    return result === undefined
-      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: "Invalid DateTime input" }))
-      : Effect.succeed(DateTime.toUtc(result))
+    return Option.match(DateTime.make(s), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(s), { message: "Invalid DateTime input" })),
+      onSome: (result) => Effect.succeed(DateTime.toUtc(result))
+    })
   },
   encode: (utc) => Effect.succeed(DateTime.formatIso(utc))
 })
@@ -1442,10 +1441,11 @@ export const dateTimeZonedFromString: Transformation<DateTime.Zoned, string> = t
   string
 >({
   decode: (s) => {
-    const result = DateTime.makeZonedFromString(s)
-    return result === undefined
-      ? Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid zoned DateTime string: ${s}` }))
-      : Effect.succeed(result)
+    return Option.match(DateTime.makeZonedFromString(s), {
+      onNone: () =>
+        Effect.fail(new Issue.InvalidValue(Option.some(s), { message: `Invalid zoned DateTime string: ${s}` })),
+      onSome: Effect.succeed
+    })
   },
   encode: (zoned) => Effect.succeed(DateTime.formatIsoZoned(zoned))
 })