effect 3.19.19 → 3.20.0

package/src/ParseResult.ts

@@ -1071,15 +1071,15 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           // handle post rest elements
           // ---------------------------------------------
           for (let j = 0; j < tail.length; j++) {
-            i += j
-            if (len < i + 1) {
+            const index = i + j
+            if (len < index + 1) {
               continue
             } else {
-              const te = tail[j](input[i], options)
+              const te = tail[j](input[index], options)
               if (isEither(te)) {
                 if (Either.isLeft(te)) {
                   // the input element is present but is not valid
-                  const e = new Pointer(i, input, te.left)
+                  const e = new Pointer(index, input, te.left)
                   if (allErrors) {
                     es.push([stepKey++, e])
                     continue
@@ -1090,7 +1090,6 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                 output.push([stepKey++, te.right])
               } else {
                 const nk = stepKey++
-                const index = i
                 if (!queue) {
                   queue = []
                 }

package/src/Scheduler.ts

@@ -21,7 +21,69 @@ export type Task = () => void
  */
 export interface Scheduler {
   shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false
-  scheduleTask(task: Task, priority: number): void
+  scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber<unknown, unknown>): void
+}
+
+/**
+ * @since 3.20.0
+ * @category models
+ */
+export class SchedulerRunner {
+  running = false
+  tasks = new PriorityBuckets()
+
+  constructor(
+    readonly scheduleDrain: (depth: number, drain: (depth: number) => void) => void
+  ) {}
+
+  private starveInternal = (depth: number) => {
+    const tasks = this.tasks.buckets
+    this.tasks.buckets = []
+    for (const [_, toRun] of tasks) {
+      for (let i = 0; i < toRun.length; i++) {
+        toRun[i]()
+      }
+    }
+    if (this.tasks.buckets.length === 0) {
+      this.running = false
+    } else {
+      this.starve(depth)
+    }
+  }
+
+  private starve(depth = 0) {
+    this.scheduleDrain(depth, this.starveInternal)
+  }
+
+  scheduleTask(task: Task, priority: number) {
+    this.tasks.scheduleTask(task, priority)
+    if (!this.running) {
+      this.running = true
+      this.starve()
+    }
+  }
+  /**
+   * @since 3.20.0
+   * @category constructors
+   */
+  static cached(
+    scheduleDrain: (depth: number, drain: (depth: number) => void) => void
+  ) {
+    const fallback = new SchedulerRunner(scheduleDrain)
+    const runners = new WeakMap<RuntimeFiber<unknown, unknown>, SchedulerRunner>()
+
+    return (fiber?: RuntimeFiber<unknown, unknown>) => {
+      if (fiber === undefined) {
+        return fallback
+      }
+      let runner = runners.get(fiber)
+      if (runner === undefined) {
+        runner = new SchedulerRunner(scheduleDrain)
+        runners.set(fiber, runner)
+      }
+      return runner
+    }
+  }
 }
 
 /**
@@ -62,14 +124,13 @@ export class PriorityBuckets<in out T = Task> {
  * @category constructors
  */
 export class MixedScheduler implements Scheduler {
-  /**
-   * @since 2.0.0
-   */
-  running = false
-  /**
-   * @since 2.0.0
-   */
-  tasks = new PriorityBuckets()
+  private readonly getRunner = SchedulerRunner.cached((depth, drain) => {
+    if (depth >= this.maxNextTickBeforeTimer) {
+      setTimeout(() => drain(0), 0)
+    } else {
+      Promise.resolve(void 0).then(() => drain(depth + 1))
+    }
+  })
 
   constructor(
     /**
@@ -78,35 +139,6 @@ export class MixedScheduler implements Scheduler {
     readonly maxNextTickBeforeTimer: number
   ) {}
 
-  /**
-   * @since 2.0.0
-   */
-  private starveInternal(depth: number) {
-    const tasks = this.tasks.buckets
-    this.tasks.buckets = []
-    for (const [_, toRun] of tasks) {
-      for (let i = 0; i < toRun.length; i++) {
-        toRun[i]()
-      }
-    }
-    if (this.tasks.buckets.length === 0) {
-      this.running = false
-    } else {
-      this.starve(depth)
-    }
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  private starve(depth = 0) {
-    if (depth >= this.maxNextTickBeforeTimer) {
-      setTimeout(() => this.starveInternal(0), 0)
-    } else {
-      Promise.resolve(void 0).then(() => this.starveInternal(depth + 1))
-    }
-  }
-
   /**
    * @since 2.0.0
    */
@@ -119,12 +151,8 @@ export class MixedScheduler implements Scheduler {
   /**
    * @since 2.0.0
    */
-  scheduleTask(task: Task, priority: number) {
-    this.tasks.scheduleTask(task, priority)
-    if (!this.running) {
-      this.running = true
-      this.starve()
-    }
+  scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber<unknown, unknown>) {
+    this.getRunner(fiber).scheduleTask(task, priority)
   }
 }
 
@@ -155,9 +183,9 @@ export class SyncScheduler implements Scheduler {
   /**
    * @since 2.0.0
    */
-  scheduleTask(task: Task, priority: number) {
+  scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber<unknown, unknown>) {
     if (this.deferred) {
-      defaultScheduler.scheduleTask(task, priority)
+      defaultScheduler.scheduleTask(task, priority, fiber)
     } else {
       this.tasks.scheduleTask(task, priority)
     }
@@ -207,9 +235,9 @@ export class ControlledScheduler implements Scheduler {
   /**
    * @since 2.0.0
    */
-  scheduleTask(task: Task, priority: number) {
+  scheduleTask(task: Task, priority: number, fiber?: RuntimeFiber<unknown, unknown>) {
     if (this.deferred) {
-      defaultScheduler.scheduleTask(task, priority)
+      defaultScheduler.scheduleTask(task, priority, fiber)
     } else {
       this.tasks.scheduleTask(task, priority)
     }
@@ -254,16 +282,16 @@ export const makeMatrix = (...record: Array<[number, Scheduler]>): Scheduler =>
       }
       return false
     },
-    scheduleTask(task, priority) {
+    scheduleTask(task, priority, fiber) {
       let scheduler: Scheduler | undefined = undefined
       for (const i of index) {
         if (priority >= i[0]) {
           scheduler = i[1]
         } else {
-          return (scheduler ?? defaultScheduler).scheduleTask(task, priority)
+          return (scheduler ?? defaultScheduler).scheduleTask(task, priority, fiber)
         }
       }
-      return (scheduler ?? defaultScheduler).scheduleTask(task, priority)
+      return (scheduler ?? defaultScheduler).scheduleTask(task, priority, fiber)
     }
   }
 }
@@ -298,31 +326,12 @@ export const makeBatched = (
   callback: (runBatch: () => void) => void,
   shouldYield: Scheduler["shouldYield"] = defaultShouldYield
 ) => {
-  let running = false
-  const tasks = new PriorityBuckets()
-  const starveInternal = () => {
-    const tasksToRun = tasks.buckets
-    tasks.buckets = []
-    for (const [_, toRun] of tasksToRun) {
-      for (let i = 0; i < toRun.length; i++) {
-        toRun[i]()
-      }
-    }
-    if (tasks.buckets.length === 0) {
-      running = false
-    } else {
-      starve()
-    }
-  }
-
-  const starve = () => callback(starveInternal)
+  const getRunner = SchedulerRunner.cached((_, drain) => {
+    callback(() => drain(0))
+  })
 
-  return make((task, priority) => {
-    tasks.scheduleTask(task, priority)
-    if (!running) {
-      running = true
-      starve()
-    }
+  return make((task, priority, fiber) => {
+    getRunner(fiber).scheduleTask(task, priority)
   }, shouldYield)
 }
 

package/src/SchemaAST.ts

@@ -2239,6 +2239,8 @@ const getIndexSignatures = (ast: AST): Array<IndexSignature> => {
       return getIndexSignatures(ast.f())
     case "Refinement":
       return getIndexSignatures(ast.from)
+    case "Transformation":
+      return getIndexSignatures(ast.to)
   }
   return []
 }
@@ -2336,6 +2338,8 @@ export const getPropertyKeyIndexedAccess = (ast: AST, name: PropertyKey): Proper
       return getPropertyKeyIndexedAccess(ast.f(), name)
     case "Refinement":
       return getPropertyKeyIndexedAccess(ast.from, name)
+    case "Transformation":
+      return getPropertyKeyIndexedAccess(ast.to, name)
   }
   throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }

package/src/Types.ts

@@ -351,3 +351,11 @@ export type NoExcessProperties<T, U> = T & { readonly [K in Exclude<keyof U, key
  * @since 3.15.0
  */
 export type Ctor<T = {}> = new(...args: Array<any>) => T
+
+/**
+ * Conditional type that returns `void` if `S` is an empty object type,
+ * otherwise returns `S`.
+ *
+ * @since 3.19.20
+ */
+export type VoidIfEmpty<S> = keyof S extends never ? void : S

package/src/internal/effect/circular.ts

@@ -70,14 +70,18 @@ class Semaphore {
   updateTakenUnsafe(fiber: Fiber.RuntimeFiber<any, any>, f: (n: number) => number): Effect.Effect<number> {
     this.taken = f(this.taken)
     if (this.waiters.size > 0) {
-      fiber.getFiberRef(currentScheduler).scheduleTask(() => {
-        const iter = this.waiters.values()
-        let item = iter.next()
-        while (item.done === false && this.free > 0) {
-          item.value()
-          item = iter.next()
-        }
-      }, fiber.getFiberRef(core.currentSchedulingPriority))
+      fiber.getFiberRef(currentScheduler).scheduleTask(
+        () => {
+          const iter = this.waiters.values()
+          let item = iter.next()
+          while (item.done === false && this.free > 0) {
+            item.value()
+            item = iter.next()
+          }
+        },
+        fiber.getFiberRef(core.currentSchedulingPriority),
+        fiber
+      )
     }
     return core.succeed(this.free)
   }
@@ -143,7 +147,7 @@ class Latch extends Effectable.Class<void> implements Effect.Latch {
       return core.void
     }
     this.scheduled = true
-    fiber.currentScheduler.scheduleTask(this.flushWaiters, fiber.getFiberRef(core.currentSchedulingPriority))
+    fiber.currentScheduler.scheduleTask(this.flushWaiters, fiber.getFiberRef(core.currentSchedulingPriority), fiber)
     return core.void
   }
   private flushWaiters = () => {

package/src/internal/fiberRuntime.ts

@@ -708,7 +708,8 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   drainQueueLaterOnExecutor() {
     this.currentScheduler.scheduleTask(
       this.run,
-      this.getFiberRef(core.currentSchedulingPriority)
+      this.getFiberRef(core.currentSchedulingPriority),
+      this
     )
   }
 
@@ -2209,9 +2210,13 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
         const results = new Array()
         const interruptAll = () =>
           fibers.forEach((fiber) => {
-            fiber.currentScheduler.scheduleTask(() => {
-              fiber.unsafeInterruptAsFork(parent.id())
-            }, 0)
+            fiber.currentScheduler.scheduleTask(
+              () => {
+                fiber.unsafeInterruptAsFork(parent.id())
+              },
+              0,
+              fiber
+            )
           })
         const startOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
         const joinOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
@@ -2234,12 +2239,16 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             parent.currentRuntimeFlags,
             fiberScope.globalScope
           )
-          parent.currentScheduler.scheduleTask(() => {
-            if (interruptImmediately) {
-              fiber.unsafeInterruptAsFork(parent.id())
-            }
-            fiber.resume(runnable)
-          }, 0)
+          parent.currentScheduler.scheduleTask(
+            () => {
+              if (interruptImmediately) {
+                fiber.unsafeInterruptAsFork(parent.id())
+              }
+              fiber.resume(runnable)
+            },
+            0,
+            fiber
+          )
           return fiber
         }
         const onInterruptSignal = () => {
@@ -2295,9 +2304,13 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                 startOrder.push(fiber)
                 fibers.add(fiber)
                 if (interrupted) {
-                  fiber.currentScheduler.scheduleTask(() => {
-                    fiber.unsafeInterruptAsFork(parent.id())
-                  }, 0)
+                  fiber.currentScheduler.scheduleTask(
+                    () => {
+                      fiber.unsafeInterruptAsFork(parent.id())
+                    },
+                    0,
+                    fiber
+                  )
                 }
                 fiber.addObserver((wrapped) => {
                   let exit: Exit.Exit<any, any> | core.Blocked

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.19.19"
+let moduleVersion = "3.20.0"
 
 export const getCurrentVersion = () => moduleVersion