effect 4.0.5 → 4.0.7

package/src/internal/arbitrary/runner.ts

@@ -3,7 +3,9 @@ import type {
   ArrayOptions,
   CheckOptions,
   CheckResult,
+  Exhausted,
   GlobalOptions,
+  Passed,
   PropertyError,
   PropertyFailure,
   Replay,
@@ -13,12 +15,16 @@ import type {
   SchemaOptions
 } from "../../Arbitrary.ts"
 import * as Effect from "../../Effect.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Option from "../../Option.ts"
 import { pipeArguments } from "../../Pipeable.ts"
+import * as Queue from "../../Queue.ts"
 import * as Random from "../../Random.ts"
 import type * as Result from "../../Result.ts"
 import * as Scheduler from "../../Scheduler.ts"
 import type * as Schema from "../../Schema.ts"
+import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import { done } from "../core.ts"
 import * as InternalRecord from "../record.ts"
 import * as Arrays from "./array.ts"
@@ -582,6 +588,111 @@ const followReplay = Effect.fnUntraced(function*<A, E, R>(
   return { _tag: "Replayed", current, failure } as const
 })
 
+interface SearchOptions {
+  readonly runs: number
+  readonly size: number
+  readonly maxDiscards: number
+  readonly seed: string | number
+  readonly maxOpsBeforeYield: number
+}
+
+interface SearchCase<A> {
+  readonly sample: Model.Sample<A>
+  readonly attempt: number
+  readonly size: number
+  readonly runs: number
+  readonly discards: number
+}
+
+interface Found<A, E> extends SearchCase<A> {
+  readonly _tag: "Found"
+  readonly failure: PropertyFailure<E>
+}
+
+type SearchResult<A, E> = Passed | Exhausted | Found<A, E>
+
+// Only the search advances this cursor. Each generated case advances size, while discards retain it.
+// This gives both search strategies the sequential seed and size schedule, independently of evaluation timing.
+const makeSearch = <A>(self: Arbitrary<A>, options: SearchOptions) => {
+  const seed = hashSeed(options.seed)
+  let runs = 0
+  let discards = 0
+  let attemptIndex = 0
+  return Effect.gen(function*(): Effect.fn.Return<SearchCase<A> | Exhausted> {
+    const size = options.runs === 1 ? options.size : Math.round(runs * options.size / (options.runs - 1))
+    while (true) {
+      const index = attemptIndex++
+      const sample = yield* generateAttempt(self.gen, seed, index, size, true)
+      if (sample._tag === "Generated") {
+        return { sample, attempt: index, size, runs: ++runs, discards }
+      }
+      if (++discards > options.maxDiscards) return { _tag: "Exhausted", runs, discards, seed: options.seed }
+      if (options.maxOpsBeforeYield <= 1 || discards % options.maxOpsBeforeYield === 0) yield* Effect.yieldNow
+    }
+  })
+}
+
+const searchSequential = Effect.fnUntraced(function*<A, E, R>(
+  next: Effect.Effect<SearchCase<A> | Exhausted>,
+  property: (value: A) => boolean | Effect.Effect<boolean, E, R>,
+  runs: number
+): Effect.fn.Return<SearchResult<A, E>, never, R> {
+  while (true) {
+    const current = yield* next
+    if ("_tag" in current) return current
+    const outcome = yield* evaluateProperty(property, current.sample.value)
+    if (outcome._tag !== "Passed") return { ...current, _tag: "Found", failure: outcome }
+    if (current.runs === runs) return { _tag: "Passed", runs, discards: current.discards }
+  }
+})
+
+const searchConcurrent = Effect.fnUntraced(function*<A, E, R>(
+  next: Effect.Effect<SearchCase<A> | Exhausted>,
+  property: (value: A) => boolean | Effect.Effect<boolean, E, R>,
+  runs: number,
+  concurrency: number
+): Effect.fn.Return<SearchResult<A, E>, never, R> {
+  interface Pending extends SearchCase<A> {
+    readonly fiber: Fiber.Fiber<typeof passedProperty | PropertyFailure<E>>
+  }
+  const queue = yield* Queue.make<Pending | Exhausted>()
+  const window = yield* Semaphore.make(concurrency)
+  const scope = yield* Scope.make("parallel")
+  const produce = Effect.gen(function*() {
+    for (let index = 0; index < runs; index++) {
+      // Hold each permit until its result is consumed, bounding both work and buffered results.
+      yield* window.take(1)
+      const current = yield* next
+      if ("_tag" in current) {
+        yield* Queue.offer(queue, current)
+        return
+      }
+      const fiber = yield* Effect.forkIn(Effect.suspend(() => evaluateProperty(property, current.sample.value)), scope)
+      yield* Queue.offer(queue, { ...current, fiber })
+    }
+  }).pipe(
+    // Queue failure follows already queued cases, so speculative generation defects cannot overtake them.
+    Effect.catchCause((cause) => Queue.failCause(queue, cause)),
+    Effect.awaitAllChildren
+  )
+  return yield* Effect.acquireUseRelease(
+    Effect.forkIn(produce, scope),
+    () =>
+      Effect.gen(function*(): Effect.fn.Return<SearchResult<A, E>, never, R> {
+        while (true) {
+          const current = yield* Queue.take(queue)
+          if ("_tag" in current) return current
+          const outcome = yield* Fiber.join(current.fiber)
+          if (outcome._tag !== "Passed") return { ...current, _tag: "Found", failure: outcome }
+          if (current.runs === runs) return { _tag: "Passed", runs, discards: current.discards }
+          yield* window.release(1)
+        }
+      }),
+    // Generator and evaluation finalizers can depend on each other, so interrupt them independently before awaiting.
+    (_, exit) => Scope.close(scope, exit)
+  )
+})
+
 /** @internal */
 export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
   self: Arbitrary<A>,
@@ -612,6 +723,7 @@ export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
 
   const defaults = globalOptions.check
   const runsTarget = positive(options?.runs ?? defaults?.runs, 100, "runs")
+  const concurrency = positive(options?.concurrency ?? defaults?.concurrency, 1, "concurrency")
   const size = natural(options?.size ?? defaults?.size, 10, "size")
   const maxDiscards = natural(
     options?.maxDiscards ?? defaults?.maxDiscards,
@@ -622,41 +734,26 @@ export const checkEffect = Effect.fnUntraced(function*<A, E, R>(
   const seedOption = options?.seed ?? defaults?.seed
   const maxOpsBeforeYield = yield* Scheduler.MaxOpsBeforeYield
   const seed = yield* resolveMasterSeed(seedOption)
-  const seedState = hashSeed(seed)
-  let runs = 0
-  let discards = 0
-  let attemptIndex = 0
-  while (runs < runsTarget) {
-    const currentAttempt = attemptIndex++
-    const currentSize = runsTarget === 1 ? size : Math.round(runs * size / (runsTarget - 1))
-    const attempt = yield* generateAttempt(self.gen, seedState, currentAttempt, currentSize, true)
-    if (attempt._tag === "Discarded") {
-      if (++discards > maxDiscards) return { _tag: "Exhausted", runs, discards, seed }
-      if (maxOpsBeforeYield <= 1 || discards % maxOpsBeforeYield === 0) yield* Effect.yieldNow
-      continue
-    }
-    const outcome = yield* evaluateProperty(property, attempt.value)
-    if (outcome._tag === "Passed") {
-      runs++
-      continue
-    }
-    const minimized = yield* shrink(attempt, outcome, property, maxShrinks)
-    return {
-      _tag: "Falsified",
-      initialInput: attempt.value,
-      shrunkInput: minimized.current.value,
-      failure: minimized.failure,
-      runs: runs + 1,
-      discards,
-      shrinks: minimized.shrinks,
-      replay: makeReplay({
-        seed,
-        attempt: currentAttempt,
-        size: currentSize,
-        path: minimized.path,
-        failureTag: outcome._tag
-      })
-    }
+  const next = makeSearch(self, { runs: runsTarget, size, maxDiscards, seed, maxOpsBeforeYield })
+  const result = yield* concurrency === 1
+    ? searchSequential(next, property, runsTarget)
+    : searchConcurrent(next, property, runsTarget, concurrency)
+  if (result._tag !== "Found") return result
+  const minimized = yield* shrink(result.sample, result.failure, property, maxShrinks)
+  return {
+    _tag: "Falsified",
+    initialInput: result.sample.value,
+    shrunkInput: minimized.current.value,
+    failure: minimized.failure,
+    runs: result.runs,
+    discards: result.discards,
+    shrinks: minimized.shrinks,
+    replay: makeReplay({
+      seed,
+      attempt: result.attempt,
+      size: result.size,
+      path: minimized.path,
+      failureTag: result.failure._tag
+    })
   }
-  return { _tag: "Passed", runs, discards }
 })

package/src/internal/core.ts

@@ -154,7 +154,7 @@ export class CauseImpl<E> implements Cause.Cause<E> {
   toJSON(): unknown {
     return {
       _id: "Cause",
-      failures: this.reasons.map((f) => f.toJSON())
+      reasons: this.reasons.map((f) => f.toJSON())
     }
   }
   toString() {
@@ -216,6 +216,8 @@ export abstract class ReasonBase<Tag extends string> implements Cause.Cause.Reas
       if (options?.overwrite !== true && newAnnotations.has(key)) return
       newAnnotations.set(key, value)
     })
+    // Keep the reason when nothing was added, so interrupts still match by identity.
+    if (options?.overwrite !== true && newAnnotations.size === this.annotations.size) return this
     const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this)
     self.annotations = newAnnotations
     return self

package/src/internal/dateTime.ts

@@ -238,8 +238,12 @@ export const makeUnsafe = <A extends DateTime.DateTime.Input>(input: A): DateTim
  * so `makeUnsafe` appends "Z" to force UTC interpretation.
  * This check prevents appending "Z" to strings that already have a zone
  * (e.g. "2024-01-01T12:00:00Z", "...+05:30", "...GMT"), which would produce invalid dates.
+ * `Date.parse` also accepts a trailing `z` or `gmt` in any case. Only that trailing
+ * match is case-insensitive, so lowercase letters in a comment like "(xyz)" do not
+ * count as a zone.
  */
-const hasZone = (input: string): boolean => /Z|GMT|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input)
+const hasZone = (input: string): boolean =>
+  /Z|GMT|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input) || /z$|gmt$/i.test(input)
 
 const minEpochMillis = -8640000000000000 + (12 * 60 * 60 * 1000)
 const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)
@@ -364,6 +368,7 @@ const formatOptions: Intl.DateTimeFormatOptions = {
   day: "numeric",
   month: "numeric",
   year: "numeric",
+  era: "short",
   hour: "numeric",
   minute: "numeric",
   second: "numeric",
@@ -428,7 +433,7 @@ export const zoneMakeNamedEffect = (zoneId: string): Effect.Effect<DateTime.Time
 export const zoneMakeLocal = (): DateTime.TimeZone.Named =>
   zoneMakeIntl(new Intl.DateTimeFormat("en-US", formatOptions))
 
-const offsetZoneRegExp = /^(?:GMT|[+-])/
+const offsetZoneRegExp = /^(?:GMT)?[+-]/
 
 /** @internal */
 export const zoneFromString = (zone: string): Option.Option<DateTime.TimeZone> => {
@@ -564,10 +569,18 @@ export const toDate = (self: DateTime.DateTime): Date => {
   } else if (self.adjustedEpochMilliseconds !== undefined) {
     return new Date(self.adjustedEpochMilliseconds)
   }
-  const parts = self.zone.format.formatToParts(self.epochMilliseconds).filter((_) => _.type !== "literal")
+  let bc = false
+  const parts = self.zone.format.formatToParts(self.epochMilliseconds).filter((_) => {
+    if (_.type === "era") {
+      bc = _.value === "BC"
+      return false
+    }
+    return _.type !== "literal"
+  })
+  const year = Number(parts[2].value)
   const date = new Date(0)
   date.setUTCFullYear(
-    Number(parts[2].value),
+    bc ? 1 - year : year,
     Number(parts[0].value) - 1,
     Number(parts[1].value)
   )
@@ -814,7 +827,7 @@ const makeZonedFromAdjusted = (
   return makeZonedProto(adjustedMillis - afterOffset, zone)
 }
 
-const offsetRegExp = /([+-])(\d{2}):(\d{2})$/
+const offsetRegExp = /([+-])(\d{2}):?(\d{2})$/
 const parseOffset = (offset: string): number | null => {
   const match = offsetRegExp.exec(offset)
   if (match === null) {
@@ -1261,10 +1274,10 @@ export const formatIntl: {
 export const formatIso = (self: DateTime.DateTime): string => toDateUtc(self).toISOString()
 
 /** @internal */
-export const formatIsoDate = (self: DateTime.DateTime): string => toDate(self).toISOString().slice(0, 10)
+export const formatIsoDate = (self: DateTime.DateTime): string => toDate(self).toISOString().split("T")[0]
 
 /** @internal */
-export const formatIsoDateUtc = (self: DateTime.DateTime): string => toDateUtc(self).toISOString().slice(0, 10)
+export const formatIsoDateUtc = (self: DateTime.DateTime): string => toDateUtc(self).toISOString().split("T")[0]
 
 /** @internal */
 export const formatIsoOffset = (self: DateTime.DateTime): string => {