effect 3.19.18 → 3.20.0

package/src/Data.ts

@@ -19,8 +19,7 @@ export declare namespace Case {
    */
   export interface Constructor<A, Tag extends keyof A = never> {
     (
-      args: Types.Equals<Omit<A, Tag>, {}> extends true ? void
-        : { readonly [P in keyof A as P extends Tag ? never : P]: A[P] }
+      args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends Tag ? never : P]: A[P] }>
     ): A
   }
 }
@@ -202,8 +201,7 @@ export const tagged = <A extends { readonly _tag: string }>(
  * @category constructors
  */
 export const Class: new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A]: A[P] }>
 ) => Readonly<A> = internal.Structural as any
 
 /**
@@ -234,8 +232,7 @@ export const Class: new<A extends Record<string, any> = {}>(
 export const TaggedClass = <Tag extends string>(
   tag: Tag
 ): new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>
 ) => Readonly<A> & { readonly _tag: Tag } => {
   class Base extends Class<any> {
     readonly _tag = tag
@@ -248,8 +245,7 @@ export const TaggedClass = <Tag extends string>(
  * @category constructors
  */
 export const Structural: new<A>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A]: A[P] }>
 ) => {} = internal.Structural as any
 
 /**
@@ -339,7 +335,7 @@ export declare namespace TaggedEnum {
     A extends { readonly _tag: string },
     K extends A["_tag"],
     E = Extract<A, { readonly _tag: K }>
-  > = { readonly [K in keyof E as K extends "_tag" ? never : K]: E[K] } extends infer T ? {} extends T ? void : T
+  > = { readonly [K in keyof E as K extends "_tag" ? never : K]: E[K] } extends infer T ? Types.VoidIfEmpty<T>
     : never
 
   /**
@@ -731,8 +727,7 @@ function taggedMatch<
  * @category constructors
  */
 export const Error: new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A]: A[P] }>
 ) => Cause.YieldableError & Readonly<A> = (function() {
   const plainArgsSymbol = Symbol.for("effect/Data/Error/plainArgs")
   const O = {
@@ -758,8 +753,7 @@ export const Error: new<A extends Record<string, any> = {}>(
  * @category constructors
  */
 export const TaggedError = <Tag extends string>(tag: Tag): new<A extends Record<string, any> = {}>(
-  args: Types.Equals<A, {}> extends true ? void
-    : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }
+  args: Types.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A> => {
   const O = {
     BaseEffectError: class extends Error<{}> {

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

@@ -47,33 +47,41 @@ class Semaphore {
     core.asyncInterrupt<number>((resume) => {
       if (this.free < n) {
         const observer = () => {
-          if (this.free < n) {
-            return
-          }
+          if (this.free < n) return
           this.waiters.delete(observer)
-          this.taken += n
-          resume(core.succeed(n))
+          resume(core.suspend(() => {
+            if (this.free < n) return this.take(n)
+            this.taken += n
+            return core.succeed(n)
+          }))
         }
         this.waiters.add(observer)
         return core.sync(() => {
           this.waiters.delete(observer)
         })
       }
-      this.taken += n
-      return resume(core.succeed(n))
+      resume(core.suspend(() => {
+        if (this.free < n) return this.take(n)
+        this.taken += n
+        return core.succeed(n)
+      }))
     })
 
   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)
   }
@@ -139,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

@@ -451,6 +451,10 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
   get await(): Effect.Effect<Exit.Exit<A, E>> {
     return core.async((resume) => {
       const cb = (exit: Exit.Exit<A, E>) => resume(core.succeed(exit))
+      if (this._exitValue !== null) {
+        cb(this._exitValue!)
+        return
+      }
       this.tell(
         FiberMessage.stateful((fiber, _) => {
           if (fiber._exitValue !== null) {
@@ -704,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
     )
   }
 
@@ -2205,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>>>()
@@ -2230,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 = () => {
@@ -2291,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/managedRuntime.ts

@@ -7,6 +7,7 @@ import type * as M from "../ManagedRuntime.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
+import * as Scheduler from "../Scheduler.js"
 import * as Scope from "../Scope.js"
 import type { Mutable } from "../Types.js"
 import * as core from "./core.js"
@@ -57,8 +58,9 @@ export const make = <R, ER>(
   memoMap = memoMap ?? internalLayer.unsafeMakeMemoMap()
   const scope = internalRuntime.unsafeRunSyncEffect(fiberRuntime.scopeMake())
   let buildFiber: Fiber.RuntimeFiber<Runtime.Runtime<R>, ER> | undefined
-  const runtimeEffect = core.withFiberRuntime<Runtime.Runtime<R>, ER>((fiber) => {
+  const runtimeEffect = core.suspend(() => {
     if (!buildFiber) {
+      const scheduler = new Scheduler.SyncScheduler()
       buildFiber = internalRuntime.unsafeForkEffect(
         core.tap(
           Scope.extend(
@@ -69,8 +71,9 @@ export const make = <R, ER>(
             self.cachedRuntime = rt
           }
         ),
-        { scope, scheduler: fiber.currentScheduler }
+        { scope, scheduler }
       )
+      scheduler.flush()
     }
     return core.flatten(buildFiber.await)
   })

package/src/internal/version.ts

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