effect 4.0.5 → 4.0.7

package/src/internal/jsonSchema.ts

@@ -0,0 +1,27 @@
+/** @internal */
+export function getSubschemaKind(keyword: string): "schema" | "map" | "array" | undefined {
+  switch (keyword) {
+    case "$defs":
+    case "properties":
+    case "patternProperties":
+    case "dependentSchemas":
+      return "map"
+    case "allOf":
+    case "anyOf":
+    case "oneOf":
+    case "prefixItems":
+      return "array"
+    case "not":
+    case "additionalProperties":
+    case "propertyNames":
+    case "unevaluatedProperties":
+    case "items":
+    case "contains":
+    case "unevaluatedItems":
+    case "if":
+    case "then":
+    case "else":
+    case "contentSchema":
+      return "schema"
+  }
+}

package/src/internal/matcher.ts

@@ -140,7 +140,7 @@ const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
     const len = predicates.length
 
     return (u: unknown) => {
-      if (!Array.isArray(u)) {
+      if (!Array.isArray(u) || u.length < len) {
         return false
       }
 

package/src/internal/record.ts

@@ -14,6 +14,12 @@ export function assignProperty(self: object, key: PropertyKey, value: unknown):
 
 /** @internal */
 export function assignProperties(self: object, source: object): void {
+  // Object.assign would fire the inherited __proto__ setter for an own __proto__ key,
+  // so use the safe per-property loop in that case.
+  if (!Object.hasOwn(source, "__proto__")) {
+    Object.assign(self, source)
+    return
+  }
   for (const key of Reflect.ownKeys(source)) {
     if (Object.prototype.propertyIsEnumerable.call(source, key)) {
       assignProperty(self, key, (source as any)[key])

package/src/internal/request.ts

@@ -10,7 +10,7 @@ import type * as Request from "../Request.ts"
 import { makeEntry } from "../Request.ts"
 import type { RequestResolver } from "../RequestResolver.ts"
 import { Scheduler } from "../Scheduler.ts"
-import { exitDie, isEffect } from "./core.ts"
+import { exitDie, isEffect, withFiber } from "./core.ts"
 import * as effect from "./effect.ts"
 
 /** @internal */
@@ -97,13 +97,14 @@ const makeBatchMap = (resolver: RequestResolver<any>): BatchMap => {
 
 interface Batch {
   key: unknown
+  context: Context.Context<never>
   resolver: RequestResolver<any>
   map: BatchMap
   readonly entrySet: Set<Request.Entry<any>>
   readonly entries: Set<Request.Entry<any>>
   readonly delayEffect: Effect<void>
   readonly run: Effect<void, unknown>
-  fiber?: Fiber<void, unknown> | undefined
+  fiber?: Fiber<unknown, unknown> | undefined
 }
 
 const batchPool: Array<Batch> = []
@@ -143,21 +144,28 @@ const addEntry = <A extends Request.Any>(
   }
   const key = resolver.batchKey(entry)
   batch = batchMap.get(key)
+  const isNewBatch = batch === undefined
   if (!batch) {
     if (batchPool.length > 0) {
       batch = batchPool.pop()!
       batch.key = key
+      batch.context = fiber.context
       batch.resolver = resolver
       batch.map = batchMap
     } else {
       const newBatch: Batch = {
         key,
+        context: fiber.context,
         resolver,
         map: batchMap,
         entrySet: new Set(),
         entries: new Set(),
         delayEffect: effect.flatMap(
-          effect.suspend(() => newBatch.resolver.delay),
+          withFiber((delayFiber) => {
+            // Reentrant delay callbacks may fill the batch and interrupt this fiber.
+            newBatch.fiber = delayFiber
+            return newBatch.resolver.delay
+          }),
           (_) => runBatch(newBatch)
         ) as Effect<void>,
         run: effect.onExit(
@@ -178,6 +186,7 @@ const addEntry = <A extends Request.Any>(
             if (batchPool.length < 128) {
               newBatch.entrySet.clear()
               newBatch.key = undefined
+              newBatch.context = undefined as any
               newBatch.fiber = undefined
               newBatch.resolver = undefined as any
               newBatch.map = undefined as any
@@ -190,15 +199,21 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.cache.scheduler })
   }
 
   batch.entrySet.add(entry)
   batch.entries.add(entry)
+  if (isNewBatch) {
+    const delayFiber = effect.runForkWith(fiber.context)(batch.delayEffect, { scheduler: fiber.cache.scheduler })
+    // A synchronous delay may have already run and recycled this batch.
+    if (completed || batchMap.get(key) !== batch) return entry
+    batch.fiber = delayFiber
+  }
+
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runForkWith(fiber.context)(runBatch(batch), { scheduler: fiber.cache.scheduler })
+  effect.runForkWith(batch.context)(runBatch(batch), { scheduler: Context.get(batch.context, Scheduler) })
   return entry
 }
 
@@ -216,7 +231,7 @@ const removeEntryUnsafe = <A extends Request.Any>(
   if (!batch.entries.delete(entry)) return
   batch.entrySet.delete(entry)
 
-  let fiber: Fiber<void, unknown> | undefined
+  let fiber: Fiber<unknown, unknown> | undefined
   if (batch.entries.size === 0) {
     batchMap.delete(key)
     fiber = batch.fiber

package/src/internal/schedule.ts

@@ -1,18 +1,14 @@
 import type * as Cause from "../Cause.ts"
 import type { Effect, Repeat, Retry } from "../Effect.ts"
-import { constant, constTrue, dual, identity } from "../Function.ts"
+import { dual, identity } from "../Function.ts"
 import * as Option from "../Option.ts"
 import * as Pull from "../Pull.ts"
-import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
 import type { NoInfer } from "../Types.ts"
 import { internalCall } from "../Utils.ts"
 import * as core from "./core.ts"
 import * as effect from "./effect.ts"
 
-const findErrorOnly = <E>(cause: Cause.Cause<E>): Result.Result<E, Cause.Cause<never>> =>
-  cause.reasons.every(core.isFailReason) ? effect.findError(cause) : Result.fail(cause as Cause.Cause<never>)
-
 /** @internal */
 export const repeatOrElse: {
   <R2, A, B, E, E2, E3, R3>(
@@ -33,21 +29,18 @@ export const repeatOrElse: {
 ): Effect<B, E3, R | R2 | R3> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
+    const loop = (input: A): Effect<B, E | E2, R | R2> =>
+      Pull.matchEffect(step(input), {
+        onSuccess(meta_) {
+          meta = meta_
+          return effect.flatMap(effect.provideService(self, Schedule.CurrentMetadata, meta), loop)
+        },
+        onFailure: effect.failCause,
+        onDone: effect.succeed
+      })
     return effect.catchCauseFilter(
-      Pull.catchDone(
-        effect.forever(
-          effect.tap(
-            effect.flatMap(effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)), step),
-            (meta_) =>
-              effect.sync(() => {
-                meta = meta_
-              })
-          ),
-          { disableYield: true }
-        ),
-        (out) => effect.succeed(out as B)
-      ),
-      findErrorOnly,
+      effect.flatMap(effect.provideService(self, Schedule.CurrentMetadata, meta), loop),
+      effect.findRecoverableError,
       (error) => orElse(error, meta.attempt === 0 ? Option.none() : Option.some(meta as any))
     )
   }))
@@ -73,7 +66,7 @@ export const retryOrElse: {
     let lastError!: E
     const loop: Effect<A, E1 | Cause.Done<A1>, R | R1> = effect.catchCauseFilter(
       effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)),
-      findErrorOnly,
+      effect.findRecoverableError,
       (error) => {
         lastError = error
         return effect.flatMap(step(error), (meta_) => {
@@ -202,25 +195,13 @@ export const scheduleFrom = dual<
   schedule: Schedule.Schedule<Output, Input, Error, Env>
 ): Effect<Output, E | Error, R | Env> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
-    let meta = Schedule.CurrentMetadata.defaultValue()
-    const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta))
-    return Pull.catchDone(
-      effect.flatMap(
-        step(initial),
-        (meta_) => {
-          meta = meta_
-          const body = constant(effect.flatMap(selfWithMeta, step))
-          return effect.whileLoop({
-            while: constTrue,
-            body,
-            step(meta_) {
-              meta = meta_
-            }
-          }) as Effect<never, E | Error | Cause.Done<Output>, R | Env>
-        }
-      ),
-      (out) => effect.succeed(out as Output)
-    )
+    const loop = (input: Input): Effect<Output, E | Error, R | Env> =>
+      Pull.matchEffect(step(input), {
+        onSuccess: (meta) => effect.flatMap(effect.provideService(self, Schedule.CurrentMetadata, meta), loop),
+        onFailure: effect.failCause,
+        onDone: effect.succeed
+      })
+    return loop(initial)
   }))
 
 const passthroughForever = Schedule.passthrough(Schedule.forever)

package/src/internal/schema/compilerRegistry.ts

@@ -58,6 +58,7 @@ export interface Entry {
   readonly is?: Is | undefined
   readonly decode?: Decode | undefined
   readonly make?: Make | undefined
+  readonly compiledMakeEffect?: Parser | undefined
   readonly decodeEffect: Parser
   readonly parser: Parser
   readonly makeEffect: Parser
@@ -117,6 +118,10 @@ class CompilerEntry extends InterpretedEntry {
     return this.save("make", this.operation("make"))
   }
 
+  get compiledMakeEffect(): Parser | undefined {
+    return this.save("compiledMakeEffect", this.operation("makeEffect"))
+  }
+
   override get decodeEffect(): Parser {
     return this.save(
       "decodeEffect",
@@ -132,7 +137,7 @@ class CompilerEntry extends InterpretedEntry {
   }
 
   override get makeEffect(): Parser {
-    const makeEffect = this.operation("makeEffect")
+    const makeEffect = this.compiledMakeEffect
     if (makeEffect !== undefined) return this.save("makeEffect", makeEffect)
     const child = (ast: SchemaAST.AST): Parser => lazyParser(this.resolve, ast, "makeEffect")
     return this.save(

package/src/internal/schema/content.ts

@@ -0,0 +1,18 @@
+const ContentTypeId = Symbol.for("~effect/Schema/content")
+
+/** @internal */
+export interface Content {
+  readonly mediaType: string
+  readonly preserveSchema: boolean
+}
+
+/** @internal */
+export function setContent<A extends object>(operation: A, content: Content): A {
+  Object.defineProperty(operation, ContentTypeId, { value: content })
+  return operation
+}
+
+/** @internal */
+export function getContent(operation: object): Content | undefined {
+  return (operation as { readonly [ContentTypeId]?: Content })[ContentTypeId]
+}