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

package/src/Duration.ts

@@ -20,12 +20,12 @@ import { dual, identity } from "./Function.ts"
 import * as Hash from "./Hash.ts"
 import type * as Inspectable from "./Inspectable.ts"
 import { NodeInspectSymbol } from "./Inspectable.ts"
+import * as Option from "./Option.ts"
 import * as order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import { hasProperty, isNumber } from "./Predicate.ts"
 import * as Reducer from "./Reducer.ts"
-import * as UndefinedOr from "./UndefinedOr.ts"
 
 const TypeId = "~effect/time/Duration"
 
@@ -228,22 +228,22 @@ const invalid = (input: unknown): never => {
 
 /**
  * Safely decodes a `Input` value into a `Duration`, returning
- * `undefined` if decoding fails.
+ * `Option.none()` if decoding fails.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
- * Duration.fromInput(1000)?.pipe(Duration.toSeconds) // 1
+ * Duration.fromInput(1000).pipe(Option.map(Duration.toSeconds)) // Some(1)
  *
- * Duration.fromInput("invalid" as any) // undefined
+ * Duration.fromInput("invalid" as any) // None
  * ```
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromInput: (u: Input) => Duration | undefined = UndefinedOr.liftThrowable(
+export const fromInput: (u: Input) => Option.Option<Duration> = Option.liftThrowable(
   fromInputUnsafe
 )
 
@@ -823,22 +823,23 @@ export const toNanosUnsafe = (self: Duration): bigint => {
 /**
  * Get the duration in nanoseconds as a bigint.
  *
- * If the duration is infinite, returns `undefined`.
+ * If the duration is infinite, returns `Option.none()`.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
- * Duration.toNanos(Duration.seconds(1)) // 1000000000n
+ * Duration.toNanos(Duration.seconds(1)) // Some(1000000000n)
  *
- * Duration.toNanos(Duration.infinity) // undefined
+ * Duration.toNanos(Duration.infinity) // None
+ * Option.getOrUndefined(Duration.toNanos(Duration.infinity)) // undefined
  * ```
  *
  * @category getters
  * @since 4.0.0
  */
-export const toNanos: (self: Duration) => bigint | undefined = UndefinedOr.liftThrowable(toNanosUnsafe)
+export const toNanos: (self: Duration) => Option.Option<bigint> = Option.liftThrowable(toNanosUnsafe)
 
 /**
  * Converts a Duration to high-resolution time format [seconds, nanoseconds].
@@ -1334,17 +1335,17 @@ export const clamp: {
 } = order.clamp(Order)
 
 /**
- * Divides a Duration by a number, returning `undefined` if division is invalid.
+ * Divides a Duration by a number, returning `Option.none()` if division is invalid.
  *
  * **Example**
  *
  * ```ts
- * import { Duration } from "effect"
+ * import { Duration, Option } from "effect"
  *
  * const d = Duration.divide(Duration.seconds(10), 2)
- * console.log(d?.pipe(Duration.toSeconds)) // 5
+ * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
  *
- * Duration.divide(Duration.seconds(10), 0) // undefined
+ * Duration.divide(Duration.seconds(10), 0) // None
  * ```
  *
  * @since 4.0.0
@@ -1352,57 +1353,57 @@ export const clamp: {
  */
 export const divide: {
   /**
-   * Divides a Duration by a number, returning `undefined` if division is invalid.
+   * Divides a Duration by a number, returning `Option.none()` if division is invalid.
    *
    * **Example**
    *
    * ```ts
-   * import { Duration } from "effect"
+   * import { Duration, Option } from "effect"
    *
    * const d = Duration.divide(Duration.seconds(10), 2)
-   * console.log(d?.pipe(Duration.toSeconds)) // 5
+   * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
    *
-   * Duration.divide(Duration.seconds(10), 0) // undefined
+   * Duration.divide(Duration.seconds(10), 0) // None
    * ```
    *
    * @since 4.0.0
    * @category math
    */
-  (by: number): (self: Duration) => Duration | undefined
+  (by: number): (self: Duration) => Option.Option<Duration>
   /**
-   * Divides a Duration by a number, returning `undefined` if division is invalid.
+   * Divides a Duration by a number, returning `Option.none()` if division is invalid.
    *
    * **Example**
    *
    * ```ts
-   * import { Duration } from "effect"
+   * import { Duration, Option } from "effect"
    *
    * const d = Duration.divide(Duration.seconds(10), 2)
-   * console.log(d?.pipe(Duration.toSeconds)) // 5
+   * console.log(Option.map(d, Duration.toSeconds)) // Some(5)
    *
-   * Duration.divide(Duration.seconds(10), 0) // undefined
+   * Duration.divide(Duration.seconds(10), 0) // None
    * ```
    *
    * @since 4.0.0
    * @category math
    */
-  (self: Duration, by: number): Duration | undefined
+  (self: Duration, by: number): Option.Option<Duration>
 } = dual(
   2,
-  (self: Duration, by: number): Duration | undefined => {
-    if (!Number.isFinite(by)) return undefined
-    if (by === 0 || Object.is(by, -0)) return undefined
+  (self: Duration, by: number): Option.Option<Duration> => {
+    if (!Number.isFinite(by)) return Option.none()
+    if (by === 0 || Object.is(by, -0)) return Option.none()
     return match(self, {
-      onMillis: (millis) => make(millis / by),
+      onMillis: (millis) => Option.some(make(millis / by)),
       onNanos: (nanos) => {
         try {
-          return make(nanos / BigInt(by))
+          return Option.some(make(nanos / BigInt(by)))
         } catch {
-          return undefined
+          return Option.none()
         }
       },
-      onInfinity: () => by > 0 ? infinity : negativeInfinity,
-      onNegativeInfinity: () => by > 0 ? negativeInfinity : infinity
+      onInfinity: () => Option.some(by > 0 ? infinity : negativeInfinity),
+      onNegativeInfinity: () => Option.some(by > 0 ? negativeInfinity : infinity)
     })
   }
 )

package/src/Effect.ts

@@ -22729,7 +22729,6 @@ export const transactionWith = <A, E, R>(
   withFiber((fiber) => {
     // Always create a new transaction state, never compose with parent
     const state: Transaction["Service"] = { journal: new Map(), retry: false }
-    const scheduler = fiber.currentScheduler
     let result: Exit.Exit<A, E> | undefined
     return uninterruptibleMask((restore) =>
       flatMap(
@@ -22750,7 +22749,7 @@ export const transactionWith = <A, E, R>(
               return clearTransaction(state)
             }
             if (Exit.isSuccess(exit)) {
-              commitTransaction(scheduler, state)
+              commitTransaction(fiber, state)
             } else {
               clearTransaction(state)
             }
@@ -22792,14 +22791,14 @@ const awaitPendingTransaction = (state: Transaction["Service"]) =>
     })
   })
 
-function commitTransaction(scheduler: Scheduler, state: Transaction["Service"]) {
+function commitTransaction(fiber: Fiber<unknown, unknown>, state: Transaction["Service"]) {
   for (const [ref, { value }] of state.journal) {
     if (value !== ref.value) {
       ref.version = ref.version + 1
       ref.value = value
     }
     for (const pending of ref.pending.values()) {
-      scheduler.scheduleTask(pending, 0)
+      fiber.currentDispatcher.scheduleTask(pending, 0)
     }
     ref.pending.clear()
   }

package/src/Fiber.ts

@@ -81,7 +81,7 @@ import type { LogLevel } from "./LogLevel.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import type { StackFrame } from "./References.ts"
-import type { Scheduler } from "./Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "./Scheduler.ts"
 import type { Scope } from "./Scope.ts"
 import type * as ServiceMap from "./ServiceMap.ts"
 import type { AnySpan } from "./Tracer.ts"
@@ -123,6 +123,7 @@ export interface Fiber<out A, out E = never> extends Pipeable {
   readonly services: ServiceMap.ServiceMap<never>
   setServices(services: ServiceMap.ServiceMap<never>): void
   readonly currentScheduler: Scheduler
+  readonly currentDispatcher: SchedulerDispatcher
   readonly currentSpan?: AnySpan | undefined
   readonly currentLogLevel: LogLevel
   readonly minimumLogLevel: LogLevel

package/src/FiberHandle.ts

@@ -10,6 +10,7 @@ import * as Filter from "./Filter.ts"
 import { dual } from "./Function.ts"
 import type * as Inspectable from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
+import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type { Scheduler } from "./Scheduler.ts"
@@ -467,20 +468,20 @@ export const set: {
  *
  *   // No fiber initially
  *   const emptyFiber = FiberHandle.getUnsafe(handle)
- *   console.log(emptyFiber === undefined) // true
+ *   console.log(emptyFiber._tag === "None") // true
  *
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber !== undefined) // true
+ *   console.log(fiber._tag === "Some") // true
  * })
  * ```
  *
  * @since 2.0.0
  * @category combinators
  */
-export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | undefined {
-  return self.state._tag === "Closed" ? undefined : self.state.fiber
+export function getUnsafe<A, E>(self: FiberHandle<A, E>): Option.Option<Fiber.Fiber<A, E>> {
+  return self.state._tag === "Closed" ? Option.none() : Option.fromUndefinedOr(self.state.fiber)
 }
 
 /**
@@ -496,10 +497,10 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *
- *   // Get the fiber (fails if no fiber)
+ *   // Get the current fiber if present
  *   const fiber = yield* FiberHandle.get(handle)
- *   if (fiber) {
- *     const result = yield* Fiber.await(fiber)
+ *   if (fiber._tag === "Some") {
+ *     const result = yield* Fiber.await(fiber.value)
  *     console.log(result) // "hello"
  *   }
  * })
@@ -508,7 +509,7 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  * @since 2.0.0
  * @category combinators
  */
-export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A, E> | undefined> {
+export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> {
   return Effect.suspend(() => Effect.succeed(getUnsafe(self)))
 }
 
@@ -528,7 +529,7 @@ export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A,
  *
  *   // The handle is now empty
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber) // undefined
+ *   console.log(fiber) // Option.none()
  * })
  * ```
  *

package/src/FiberMap.ts

@@ -500,8 +500,8 @@ export const set: {
  *
  *   // Retrieve the fiber
  *   const retrieved = FiberMap.getUnsafe(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -527,8 +527,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -537,7 +537,7 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Fiber.Fiber<A, E> | undefined
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.Fiber<A, E>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
@@ -554,8 +554,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -564,18 +564,18 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined => {
-    return self.state._tag === "Closed" ? undefined : Option.getOrUndefined(MutableHashMap.get(self.state.backing, key))
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>> => {
+    return self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key)
   }
 )
 
 /**
  * Retrieve a fiber from the FiberMap.
  *
- * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+ * Returns an `Option` wrapped in `Effect`.
  *
  * @example
  * ```ts
@@ -590,8 +590,8 @@ export const getUnsafe: {
  *
  *   // Retrieve the fiber with error handling
  *   const retrieved = yield* FiberMap.get(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -604,7 +604,7 @@ export const get: {
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -619,8 +619,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -629,11 +629,11 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -648,8 +648,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -658,10 +658,10 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined> =>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> =>
     Effect.suspend(() => Effect.succeed(getUnsafe(self, key)))
 )
 

package/src/FileSystem.ts

@@ -41,6 +41,7 @@ import * as Cause from "./Cause.ts"
 import * as Effect from "./Effect.ts"
 import { pipe } from "./Function.ts"
 import * as Layer from "./Layer.ts"
+import * as Option from "./Option.ts"
 import { badArgument, type PlatformError, systemError } from "./PlatformError.ts"
 import type * as Pull from "./Pull.ts"
 import type { Scope } from "./Scope.ts"
@@ -759,7 +760,7 @@ export const make = (
       const readChunk = file.readAlloc(chunkSize)
       return Stream.fromPull(Effect.succeed(
         Effect.flatMap(
-          Effect.suspend((): Pull.Pull<Uint8Array | undefined, PlatformError> => {
+          Effect.suspend((): Pull.Pull<Option.Option<Uint8Array>, PlatformError> => {
             if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
               return Cause.done()
             }
@@ -767,11 +768,13 @@ export const make = (
               ? file.readAlloc(bytesToRead - totalBytesRead)
               : readChunk
           }),
-          (buf) => {
-            if (!buf) return Cause.done()
-            totalBytesRead += BigInt(buf.length)
-            return Effect.succeed(Arr.of(buf))
-          }
+          Option.match({
+            onNone: () => Cause.done(),
+            onSome: (buf) => {
+              totalBytesRead += BigInt(buf.length)
+              return Effect.succeed(Arr.of(buf))
+            }
+          })
         )
       ))
     }, Stream.unwrap),
@@ -1046,7 +1049,7 @@ export interface File {
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
   readonly sync: Effect.Effect<void, PlatformError>
   readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError>
-  readonly readAlloc: (size: SizeInput) => Effect.Effect<Uint8Array | undefined, PlatformError>
+  readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError>
   readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError>
   readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError>
   readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError>
@@ -1096,7 +1099,7 @@ export declare namespace File {
    *
    * @example
    * ```ts
-   * import { Console, Effect, FileSystem } from "effect"
+   * import { Console, Effect, FileSystem, Option } from "effect"
    *
    * const program = Effect.gen(function*() {
    *   const fs = yield* FileSystem.FileSystem
@@ -1108,7 +1111,7 @@ export declare namespace File {
    *   yield* Console.log(`Mode: ${info.mode.toString(8)}`) // Octal permissions
    *
    *   // Handle optional timestamps
-   *   const mtime = info.mtime ?? new Date(0)
+   *   const mtime = Option.getOrElse(info.mtime, () => new Date(0))
    *   yield* Console.log(`Modified: ${mtime.toISOString()}`)
    *
    *   // Check if it's a regular file
@@ -1123,19 +1126,19 @@ export declare namespace File {
    */
   export interface Info {
     readonly type: Type
-    readonly mtime: Date | undefined
-    readonly atime: Date | undefined
-    readonly birthtime: Date | undefined
+    readonly mtime: Option.Option<Date>
+    readonly atime: Option.Option<Date>
+    readonly birthtime: Option.Option<Date>
     readonly dev: number
-    readonly ino: number | undefined
+    readonly ino: Option.Option<number>
     readonly mode: number
-    readonly nlink: number | undefined
-    readonly uid: number | undefined
-    readonly gid: number | undefined
-    readonly rdev: number | undefined
+    readonly nlink: Option.Option<number>
+    readonly uid: Option.Option<number>
+    readonly gid: Option.Option<number>
+    readonly rdev: Option.Option<number>
     readonly size: Size
-    readonly blksize: Size | undefined
-    readonly blocks: number | undefined
+    readonly blksize: Option.Option<Size>
+    readonly blocks: Option.Option<number>
   }
 }
 
@@ -1226,13 +1229,13 @@ export declare namespace WatchEvent {
  *
  * @example
  * ```ts
- * import { Effect, FileSystem, Stream } from "effect"
+ * import { Effect, FileSystem, Option, Stream } from "effect"
  *
  * // Custom watch backend implementation
  * const customWatchBackend = {
  *   register: (path: string, stat: FileSystem.File.Info) => {
  *     // Implementation would depend on platform
- *     return Stream.empty // Placeholder implementation
+ *     return Option.some(Stream.empty) // Placeholder implementation
  *   }
  * }
  *
@@ -1255,5 +1258,5 @@ export declare namespace WatchEvent {
  * @category file watcher
  */
 export class WatchBackend extends ServiceMap.Service<WatchBackend, {
-  readonly register: (path: string, stat: File.Info) => Stream.Stream<WatchEvent, PlatformError> | undefined
+  readonly register: (path: string, stat: File.Info) => Option.Option<Stream.Stream<WatchEvent, PlatformError>>
 }>()("effect/platform/FileSystem/WatchBackend") {}