effect 4.0.0-beta.30 → 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
  */