effect 3.12.3 → 3.12.5

package/src/Arbitrary.ts

@@ -4,6 +4,7 @@
 
 import * as Arr from "./Array.js"
 import * as FastCheck from "./FastCheck.js"
+import { globalValue } from "./GlobalValue.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as schemaId_ from "./internal/schema/schemaId.js"
 import * as util_ from "./internal/schema/util.js"
@@ -276,6 +277,11 @@ const makeArrayConfig = (options: {
 
 type Config = StringConstraints | NumberConstraints | BigIntConstraints | DateConstraints | ArrayConfig
 
+const arbitraryMemoMap = globalValue(
+  Symbol.for("effect/Arbitrary/arbitraryMemoMap"),
+  () => new WeakMap<AST.AST, LazyArbitrary<any>>()
+)
+
 const go = (
   ast: AST.AST,
   ctx: ArbitraryGenerationContext,
@@ -311,6 +317,7 @@ const go = (
 const constStringConstraints = makeStringConstraints({})
 const constNumberConstraints = makeNumberConstraints({})
 const constBigIntConstraints = makeBigIntConstraints({})
+const defaultSuspendedArrayConstraints: FastCheck.ArrayConstraints = { maxLength: 2 }
 
 /** @internal */
 export const toOp = (
@@ -439,8 +446,22 @@ export const toOp = (
           const value = indexSignatures[i][1](fc)
           output = output.chain((o) => {
             const item = fc.tuple(key, value)
+            /*
+
+              `getSuspendedArray` is used to generate less key/value pairs in
+              the context of a recursive schema. Without it, the following schema
+              would generate an big amount of values possibly leading to a stack
+              overflow:
+
+              ```ts
+              type A = { [_: string]: A }
+
+              const schema = S.Record({ key: S.String, value: S.suspend((): S.Schema<A> => schema) })
+              ```
+
+            */
             const arr = ctx.depthIdentifier !== undefined ?
-              getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item) :
+              getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, defaultSuspendedArrayConstraints) :
               fc.array(item)
             return arr.map((tuples) => ({ ...Object.fromEntries(tuples), ...o }))
           })
@@ -454,16 +475,39 @@ export const toOp = (
       return new Succeed((fc) => fc.oneof(...types.map((arb) => arb(fc))))
     }
     case "Suspend": {
+      const memo = arbitraryMemoMap.get(ast)
+      if (memo) {
+        return new Succeed(memo)
+      }
       const get = util_.memoizeThunk(() => {
         return go(ast.f(), getSuspendedContext(ctx, ast), path)
       })
-      return new Succeed((fc) => fc.constant(null).chain(() => get()(fc)))
+      const out: LazyArbitrary<any> = (fc) => fc.constant(null).chain(() => get()(fc))
+      arbitraryMemoMap.set(ast, out)
+      return new Succeed(out)
     }
     case "Transformation":
       return toOp(ast.to, ctx, path)
   }
 }
 
+function subtractElementsLength(
+  constraints: FastCheck.ArrayConstraints,
+  elementsLength: number
+): FastCheck.ArrayConstraints {
+  if (elementsLength === 0 || (constraints.minLength === undefined && constraints.maxLength === undefined)) {
+    return constraints
+  }
+  const out = { ...constraints }
+  if (out.minLength !== undefined) {
+    out.minLength = Math.max(out.minLength - elementsLength, 0)
+  }
+  if (out.maxLength !== undefined) {
+    out.maxLength = Math.max(out.maxLength - elementsLength, 0)
+  }
+  return out
+}
+
 const goTupleType = (
   ast: AST.TupleType,
   ctx: ArbitraryGenerationContext,
@@ -508,9 +552,36 @@ const goTupleType = (
       const [head, ...tail] = rest
       const item = head(fc)
       output = output.chain((as) => {
-        return (ctx.depthIdentifier !== undefined
-          ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, constraints)
-          : fc.array(item, constraints)).map((rest) => [...as, ...rest])
+        const len = as.length
+        // We must adjust the constraints for the rest element
+        // because the elements might have generated some values
+        const restArrayConstraints = subtractElementsLength(constraints, len)
+        if (restArrayConstraints.maxLength === 0) {
+          return fc.constant(as)
+        }
+        /*
+
+          `getSuspendedArray` is used to generate less values in
+          the context of a recursive schema. Without it, the following schema
+          would generate an big amount of values possibly leading to a stack
+          overflow:
+
+          ```ts
+          type A = ReadonlyArray<A | null>
+
+          const schema = S.Array(
+            S.NullOr(S.suspend((): S.Schema<A> => schema))
+          )
+          ```
+
+        */
+        const arr = ctx.depthIdentifier !== undefined
+          ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, restArrayConstraints)
+          : fc.array(item, restArrayConstraints)
+        if (len === 0) {
+          return arr
+        }
+        return arr.map((rest) => [...as, ...rest])
       })
       // ---------------------------------------------
       // handle post rest elements
@@ -660,20 +731,19 @@ const getSuspendedArray = (
   depthIdentifier: string,
   maxDepth: number,
   item: FastCheck.Arbitrary<any>,
-  constraints?: FastCheck.ArrayConstraints
+  constraints: FastCheck.ArrayConstraints
 ) => {
-  let minLength = 1
-  let maxLength = 2
-  if (constraints && constraints.minLength !== undefined && constraints.minLength > minLength) {
-    minLength = constraints.minLength
-    if (minLength > maxLength) {
-      maxLength = minLength
-    }
+  // In the context of a recursive schema, we don't want a `maxLength` greater than 2.
+  // The only exception is when `minLength` is also set, in which case we set
+  // `maxLength` to the minimum value, which is `minLength`.
+  const maxLengthLimit = Math.max(2, constraints.minLength ?? 0)
+  if (constraints.maxLength !== undefined && constraints.maxLength > maxLengthLimit) {
+    constraints = { ...constraints, maxLength: maxLengthLimit }
   }
   return fc.oneof(
     { maxDepth, depthIdentifier },
     fc.constant([]),
-    fc.array(item, { minLength, maxLength })
+    fc.array(item, constraints)
   )
 }
 

package/src/DateTime.ts

@@ -43,8 +43,7 @@ export type DateTime = Utc | Zoned
 export interface Utc extends DateTime.Proto {
   readonly _tag: "Utc"
   readonly epochMillis: number
-  /** @internal */
-  partsUtc: DateTime.PartsWithWeekday
+  partsUtc: DateTime.PartsWithWeekday | undefined
 }
 
 /**
@@ -55,12 +54,9 @@ export interface Zoned extends DateTime.Proto {
   readonly _tag: "Zoned"
   readonly epochMillis: number
   readonly zone: TimeZone
-  /** @internal */
-  adjustedEpochMillis?: number
-  /** @internal */
-  partsAdjusted?: DateTime.PartsWithWeekday
-  /** @internal */
-  partsUtc?: DateTime.PartsWithWeekday
+  adjustedEpochMillis: number | undefined
+  partsAdjusted: DateTime.PartsWithWeekday | undefined
+  partsUtc: DateTime.PartsWithWeekday | undefined
 }
 
 /**
@@ -282,11 +278,16 @@ export const clamp: {
   /**
    * @since 3.6.0
    */
-  (options: { minimum: DateTime; maximum: DateTime }): (self: DateTime) => DateTime
+  <Min extends DateTime, Max extends DateTime>(
+    options: { readonly minimum: Min; readonly maximum: Max }
+  ): <A extends DateTime>(self: A) => A | Min | Max
   /**
    * @since 3.6.0
    */
-  (self: DateTime, options: { minimum: DateTime; maximum: DateTime }): DateTime
+  <A extends DateTime, Min extends DateTime, Max extends DateTime>(
+    self: A,
+    options: { readonly minimum: Min; readonly maximum: Max }
+  ): A | Min | Max
 } = Internal.clamp
 
 // =============================================================================
@@ -1032,12 +1033,12 @@ export const min: {
    * @since 3.6.0
    * @category comparisons
    */
-  (that: DateTime): (self: DateTime) => DateTime
+  <That extends DateTime>(that: That): <Self extends DateTime>(self: Self) => Self | That
   /**
    * @since 3.6.0
    * @category comparisons
    */
-  (self: DateTime, that: DateTime): DateTime
+  <Self extends DateTime, That extends DateTime>(self: Self, that: That): Self | That
 } = Internal.min
 
 /**
@@ -1049,12 +1050,12 @@ export const max: {
    * @since 3.6.0
    * @category comparisons
    */
-  (that: DateTime): (self: DateTime) => DateTime
+  <That extends DateTime>(that: That): <Self extends DateTime>(self: Self) => Self | That
   /**
    * @since 3.6.0
    * @category comparisons
    */
-  (self: DateTime, that: DateTime): DateTime
+  <Self extends DateTime, That extends DateTime>(self: Self, that: That): Self | That
 } = Internal.max
 
 /**
@@ -1381,7 +1382,7 @@ export const setParts: {
    * @since 3.6.0
    * @category parts
    */
-  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A
   /**
    * Set the different parts of a `DateTime` as an object.
    *
@@ -1390,7 +1391,7 @@ export const setParts: {
    * @since 3.6.0
    * @category parts
    */
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A
 } = Internal.setParts
 
 /**
@@ -1406,14 +1407,14 @@ export const setPartsUtc: {
    * @since 3.6.0
    * @category parts
    */
-  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (parts: Partial<DateTime.PartsWithWeekday>): <A extends DateTime>(self: A) => A
   /**
    * Set the different parts of a `DateTime` as an object.
    *
    * @since 3.6.0
    * @category parts
    */
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsWithWeekday>): A
 } = Internal.setPartsUtc
 
 // =============================================================================
@@ -1698,7 +1699,7 @@ export const mutate: {
    * @since 3.6.0
    * @category mapping
    */
-  (f: (date: Date) => void): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (f: (date: Date) => void): <A extends DateTime>(self: A) => A
   // =============================================================================
   // mapping
   // =============================================================================
@@ -1712,7 +1713,7 @@ export const mutate: {
    * @since 3.6.0
    * @category mapping
    */
-  <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, f: (date: Date) => void): A
 } = Internal.mutate
 
 /**
@@ -1728,14 +1729,14 @@ export const mutateUtc: {
    * @since 3.6.0
    * @category mapping
    */
-  (f: (date: Date) => void): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (f: (date: Date) => void): <A extends DateTime>(self: A) => A
   /**
    * Modify a `DateTime` by applying a function to a cloned UTC `Date` instance.
    *
    * @since 3.6.0
    * @category mapping
    */
-  <A extends DateTime>(self: A, f: (date: Date) => void): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, f: (date: Date) => void): A
 } = Internal.mutateUtc
 
 /**
@@ -1771,7 +1772,7 @@ export const mapEpochMillis: {
    * )
    * ```
    */
-  (f: (millis: number) => number): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (f: (millis: number) => number): <A extends DateTime>(self: A) => A
   /**
    * Transform a `DateTime` by applying a function to the number of milliseconds
    * since the Unix epoch.
@@ -1788,7 +1789,7 @@ export const mapEpochMillis: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, f: (millis: number) => number): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, f: (millis: number) => number): A
 } = Internal.mapEpochMillis
 
 /**
@@ -1964,7 +1965,7 @@ export const addDuration: {
    * )
    * ```
    */
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
   // =============================================================================
   // math
   // =============================================================================
@@ -1984,7 +1985,7 @@ export const addDuration: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
 } = Internal.addDuration
 
 /**
@@ -2018,7 +2019,7 @@ export const subtractDuration: {
    * )
    * ```
    */
-  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (duration: Duration.DurationInput): <A extends DateTime>(self: A) => A
   /**
    * Subtract the given `Duration` from a `DateTime`.
    *
@@ -2034,7 +2035,7 @@ export const subtractDuration: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, duration: Duration.DurationInput): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, duration: Duration.DurationInput): A
 } = Internal.subtractDuration
 
 /**
@@ -2074,7 +2075,7 @@ export const add: {
    * )
    * ```
    */
-  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => A
   /**
    * Add the given `amount` of `unit`'s to a `DateTime`.
    *
@@ -2093,7 +2094,7 @@ export const add: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): A
 } = Internal.add
 
 /**
@@ -2127,7 +2128,7 @@ export const subtract: {
    * )
    * ```
    */
-  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+  (parts: Partial<DateTime.PartsForMath>): <A extends DateTime>(self: A) => A
   /**
    * Subtract the given `amount` of `unit`'s from a `DateTime`.
    *
@@ -2143,7 +2144,7 @@ export const subtract: {
    * )
    * ```
    */
-  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): DateTime.PreserveZone<A>
+  <A extends DateTime>(self: A, parts: Partial<DateTime.PartsForMath>): A
 } = Internal.subtract
 
 /**
@@ -2187,10 +2188,8 @@ export const startOf: {
    */
   (
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): <A extends DateTime>(self: A) => A
   /**
    * Converts a `DateTime` to the start of the given `part`.
    *
@@ -2213,10 +2212,8 @@ export const startOf: {
   <A extends DateTime>(
     self: A,
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): A
 } = Internal.startOf
 
 /**
@@ -2260,10 +2257,8 @@ export const endOf: {
    */
   (
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): <A extends DateTime>(self: A) => A
   /**
    * Converts a `DateTime` to the end of the given `part`.
    *
@@ -2286,10 +2281,8 @@ export const endOf: {
   <A extends DateTime>(
     self: A,
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): A
 } = Internal.endOf
 
 /**
@@ -2333,10 +2326,8 @@ export const nearest: {
    */
   (
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): <A extends DateTime>(self: A) => DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): <A extends DateTime>(self: A) => A
   /**
    * Converts a `DateTime` to the nearest given `part`.
    *
@@ -2359,10 +2350,8 @@ export const nearest: {
   <A extends DateTime>(
     self: A,
     part: DateTime.UnitSingular,
-    options?: {
-      readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined
-    }
-  ): DateTime.PreserveZone<A>
+    options?: { readonly weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined }
+  ): A
 } = Internal.nearest
 
 // =============================================================================

package/src/Inspectable.ts

@@ -1,7 +1,6 @@
 /**
  * @since 2.0.0
  */
-
 import type * as FiberRefs from "./FiberRefs.js"
 import { globalValue } from "./GlobalValue.js"
 import { hasProperty, isFunction } from "./Predicate.js"

package/src/Layer.ts

@@ -865,7 +865,7 @@ export const retry: {
    * @category retrying
    */
   <X, E, RIn2>(
-    schedule: Schedule.Schedule<X, E, RIn2>
+    schedule: Schedule.Schedule<X, NoInfer<E>, RIn2>
   ): <ROut, RIn>(self: Layer<ROut, E, RIn>) => Layer<ROut, E, RIn2 | RIn>
   /**
    * Retries constructing this layer according to the specified schedule.

package/src/MetricPolling.ts

@@ -128,7 +128,7 @@ export const retry: {
    * @category constructors
    */
   <X, E, R2>(
-    policy: Schedule.Schedule<X, E, R2>
+    policy: Schedule.Schedule<X, NoInfer<E>, R2>
   ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
   /**
    * Returns a new polling metric whose poll function will be retried with the

package/src/ParseResult.ts

@@ -809,11 +809,11 @@ interface Parser {
 }
 
 const decodeMemoMap = globalValue(
-  Symbol.for("effect/Schema/Parser/decodeMemoMap"),
+  Symbol.for("effect/ParseResult/decodeMemoMap"),
   () => new WeakMap<AST.AST, Parser>()
 )
 const encodeMemoMap = globalValue(
-  Symbol.for("effect/Schema/Parser/encodeMemoMap"),
+  Symbol.for("effect/ParseResult/encodeMemoMap"),
   () => new WeakMap<AST.AST, Parser>()
 )
 
@@ -1983,12 +1983,25 @@ const formatTree = (
 }
 
 /**
+ * Represents an issue returned by the {@link ArrayFormatter} formatter.
+ *
  * @category model
  * @since 3.10.0
  */
 export interface ArrayFormatterIssue {
+  /**
+   * The tag identifying the type of parse issue.
+   */
   readonly _tag: ParseIssue["_tag"]
+
+  /**
+   * The path to the property where the issue occurred.
+   */
   readonly path: ReadonlyArray<PropertyKey>
+
+  /**
+   * A descriptive message explaining the issue.
+   */
   readonly message: string
 }