@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/Arbitrary.ts

@@ -1,1101 +0,0 @@
-/**
- * @since 3.10.0
- */
-
-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"
-import * as Option from "./Option.js"
-import * as Predicate from "./Predicate.js"
-import type * as Schema from "./Schema.js"
-import * as SchemaAST from "./SchemaAST.js"
-import type * as Types from "./Types.js"
-
-/**
- * @category model
- * @since 3.10.0
- */
-export interface LazyArbitrary<A> {
-  (fc: typeof FastCheck): FastCheck.Arbitrary<A>
-}
-
-/**
- * @category annotations
- * @since 3.10.0
- */
-export interface ArbitraryGenerationContext {
-  readonly maxDepth: number
-  readonly depthIdentifier?: string
-  readonly constraints?: StringConstraints | NumberConstraints | BigIntConstraints | DateConstraints | ArrayConstraints
-}
-
-/**
- * @category annotations
- * @since 3.10.0
- */
-export type ArbitraryAnnotation<A, TypeParameters extends ReadonlyArray<any> = readonly []> = (
-  ...arbitraries: [
-    ...{ readonly [K in keyof TypeParameters]: LazyArbitrary<TypeParameters[K]> },
-    ctx: ArbitraryGenerationContext
-  ]
-) => LazyArbitrary<A>
-
-/**
- * Returns a LazyArbitrary for the `A` type of the provided schema.
- *
- * @category arbitrary
- * @since 3.10.0
- */
-export const makeLazy = <A, I, R>(schema: Schema.Schema<A, I, R>): LazyArbitrary<A> => {
-  const description = getDescription(schema.ast, [])
-  return go(description, { maxDepth: 2 })
-}
-
-/**
- * Returns a fast-check Arbitrary for the `A` type of the provided schema.
- *
- * @category arbitrary
- * @since 3.10.0
- */
-export const make = <A, I, R>(schema: Schema.Schema<A, I, R>): FastCheck.Arbitrary<A> => makeLazy(schema)(FastCheck)
-
-interface StringConstraints {
-  readonly _tag: "StringConstraints"
-  readonly constraints: FastCheck.StringSharedConstraints
-  readonly pattern?: string
-}
-
-/** @internal */
-export const makeStringConstraints = (options: {
-  readonly minLength?: number | undefined
-  readonly maxLength?: number | undefined
-  readonly pattern?: string | undefined
-}): StringConstraints => {
-  const out: Types.Mutable<StringConstraints> = {
-    _tag: "StringConstraints",
-    constraints: {}
-  }
-  if (Predicate.isNumber(options.minLength)) {
-    out.constraints.minLength = options.minLength
-  }
-  if (Predicate.isNumber(options.maxLength)) {
-    out.constraints.maxLength = options.maxLength
-  }
-  if (Predicate.isString(options.pattern)) {
-    out.pattern = options.pattern
-  }
-  return out
-}
-
-interface NumberConstraints {
-  readonly _tag: "NumberConstraints"
-  readonly constraints: FastCheck.FloatConstraints
-  readonly isInteger: boolean
-}
-
-/** @internal */
-export const makeNumberConstraints = (options: {
-  readonly isInteger?: boolean | undefined
-  readonly min?: unknown
-  readonly minExcluded?: boolean | undefined
-  readonly max?: unknown
-  readonly maxExcluded?: boolean | undefined
-  readonly noNaN?: boolean | undefined
-  readonly noDefaultInfinity?: boolean | undefined
-}): NumberConstraints => {
-  const out: Types.Mutable<NumberConstraints> = {
-    _tag: "NumberConstraints",
-    constraints: {},
-    isInteger: options.isInteger ?? false
-  }
-  if (Predicate.isNumber(options.min)) {
-    out.constraints.min = Math.fround(options.min)
-  }
-  if (Predicate.isBoolean(options.minExcluded)) {
-    out.constraints.minExcluded = options.minExcluded
-  }
-  if (Predicate.isNumber(options.max)) {
-    out.constraints.max = Math.fround(options.max)
-  }
-  if (Predicate.isBoolean(options.maxExcluded)) {
-    out.constraints.maxExcluded = options.maxExcluded
-  }
-  if (Predicate.isBoolean(options.noNaN)) {
-    out.constraints.noNaN = options.noNaN
-  }
-  if (Predicate.isBoolean(options.noDefaultInfinity)) {
-    out.constraints.noDefaultInfinity = options.noDefaultInfinity
-  }
-  return out
-}
-
-interface BigIntConstraints {
-  readonly _tag: "BigIntConstraints"
-  readonly constraints: FastCheck.BigIntConstraints
-}
-
-/** @internal */
-export const makeBigIntConstraints = (options: {
-  readonly min?: bigint | undefined
-  readonly max?: bigint | undefined
-}): BigIntConstraints => {
-  const out: Types.Mutable<BigIntConstraints> = {
-    _tag: "BigIntConstraints",
-    constraints: {}
-  }
-  if (Predicate.isBigInt(options.min)) {
-    out.constraints.min = options.min
-  }
-  if (Predicate.isBigInt(options.max)) {
-    out.constraints.max = options.max
-  }
-  return out
-}
-
-interface ArrayConstraints {
-  readonly _tag: "ArrayConstraints"
-  readonly constraints: FastCheck.ArrayConstraints
-}
-
-/** @internal */
-export const makeArrayConstraints = (options: {
-  readonly minLength?: unknown
-  readonly maxLength?: unknown
-}): ArrayConstraints => {
-  const out: Types.Mutable<ArrayConstraints> = {
-    _tag: "ArrayConstraints",
-    constraints: {}
-  }
-  if (Predicate.isNumber(options.minLength)) {
-    out.constraints.minLength = options.minLength
-  }
-  if (Predicate.isNumber(options.maxLength)) {
-    out.constraints.maxLength = options.maxLength
-  }
-  return out
-}
-
-interface DateConstraints {
-  readonly _tag: "DateConstraints"
-  readonly constraints: FastCheck.DateConstraints
-}
-
-/** @internal */
-export const makeDateConstraints = (options: {
-  readonly min?: Date | undefined
-  readonly max?: Date | undefined
-  readonly noInvalidDate?: boolean | undefined
-}): DateConstraints => {
-  const out: Types.Mutable<DateConstraints> = {
-    _tag: "DateConstraints",
-    constraints: {}
-  }
-  if (Predicate.isDate(options.min)) {
-    out.constraints.min = options.min
-  }
-  if (Predicate.isDate(options.max)) {
-    out.constraints.max = options.max
-  }
-  if (Predicate.isBoolean(options.noInvalidDate)) {
-    out.constraints.noInvalidDate = options.noInvalidDate
-  }
-  return out
-}
-
-type Refinements = ReadonlyArray<SchemaAST.Refinement>
-
-interface Base {
-  readonly path: ReadonlyArray<PropertyKey>
-  readonly refinements: Refinements
-  readonly annotations: ReadonlyArray<ArbitraryAnnotation<any, any>>
-}
-
-interface StringKeyword extends Base {
-  readonly _tag: "StringKeyword"
-  readonly constraints: ReadonlyArray<StringConstraints>
-}
-
-interface NumberKeyword extends Base {
-  readonly _tag: "NumberKeyword"
-  readonly constraints: ReadonlyArray<NumberConstraints>
-}
-
-interface BigIntKeyword extends Base {
-  readonly _tag: "BigIntKeyword"
-  readonly constraints: ReadonlyArray<BigIntConstraints>
-}
-
-interface DateFromSelf extends Base {
-  readonly _tag: "DateFromSelf"
-  readonly constraints: ReadonlyArray<DateConstraints>
-}
-
-interface Declaration extends Base {
-  readonly _tag: "Declaration"
-  readonly typeParameters: ReadonlyArray<Description>
-  readonly ast: SchemaAST.AST
-}
-
-interface TupleType extends Base {
-  readonly _tag: "TupleType"
-  readonly constraints: ReadonlyArray<ArrayConstraints>
-  readonly elements: ReadonlyArray<{
-    readonly isOptional: boolean
-    readonly description: Description
-  }>
-  readonly rest: ReadonlyArray<Description>
-}
-
-interface TypeLiteral extends Base {
-  readonly _tag: "TypeLiteral"
-  readonly propertySignatures: ReadonlyArray<{
-    readonly isOptional: boolean
-    readonly name: PropertyKey
-    readonly value: Description
-  }>
-  readonly indexSignatures: ReadonlyArray<{
-    readonly parameter: Description
-    readonly value: Description
-  }>
-}
-
-interface Union extends Base {
-  readonly _tag: "Union"
-  readonly members: ReadonlyArray<Description>
-}
-
-interface Suspend extends Base {
-  readonly _tag: "Suspend"
-  readonly id: string
-  readonly ast: SchemaAST.AST
-  readonly description: () => Description
-}
-
-interface Ref extends Base {
-  readonly _tag: "Ref"
-  readonly id: string
-  readonly ast: SchemaAST.AST
-}
-
-interface NeverKeyword extends Base {
-  readonly _tag: "NeverKeyword"
-  readonly ast: SchemaAST.AST
-}
-
-interface Keyword extends Base {
-  readonly _tag: "Keyword"
-  readonly value:
-    | "UndefinedKeyword"
-    | "VoidKeyword"
-    | "UnknownKeyword"
-    | "AnyKeyword"
-    | "BooleanKeyword"
-    | "SymbolKeyword"
-    | "ObjectKeyword"
-}
-
-interface Literal extends Base {
-  readonly _tag: "Literal"
-  readonly literal: SchemaAST.LiteralValue
-}
-
-interface UniqueSymbol extends Base {
-  readonly _tag: "UniqueSymbol"
-  readonly symbol: symbol
-}
-
-interface Enums extends Base {
-  readonly _tag: "Enums"
-  readonly enums: ReadonlyArray<readonly [string, string | number]>
-  readonly ast: SchemaAST.AST
-}
-
-interface TemplateLiteral extends Base {
-  readonly _tag: "TemplateLiteral"
-  readonly head: string
-  readonly spans: ReadonlyArray<{
-    readonly description: Description
-    readonly literal: string
-  }>
-}
-
-type Description =
-  | Declaration
-  | NeverKeyword
-  | Keyword
-  | Literal
-  | UniqueSymbol
-  | Enums
-  | TemplateLiteral
-  | StringKeyword
-  | NumberKeyword
-  | BigIntKeyword
-  | DateFromSelf
-  | TupleType
-  | TypeLiteral
-  | Union
-  | Suspend
-  | Ref
-
-const getArbitraryAnnotation = SchemaAST.getAnnotation<ArbitraryAnnotation<any, any>>(SchemaAST.ArbitraryAnnotationId)
-
-const getASTConstraints = (ast: SchemaAST.AST) => {
-  const TypeAnnotationId = ast.annotations[SchemaAST.SchemaIdAnnotationId]
-  if (Predicate.isPropertyKey(TypeAnnotationId)) {
-    const out = ast.annotations[TypeAnnotationId]
-    if (Predicate.isReadonlyRecord(out)) {
-      return out
-    }
-  }
-}
-
-const idMemoMap = globalValue(
-  Symbol.for("effect/Arbitrary/IdMemoMap"),
-  () => new Map<SchemaAST.AST, string>()
-)
-
-let counter = 0
-
-function wrapGetDescription(
-  f: (ast: SchemaAST.AST, description: Description) => Description,
-  g: (ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>) => Description
-): (ast: SchemaAST.AST, path: ReadonlyArray<PropertyKey>) => Description {
-  return (ast, path) => f(ast, g(ast, path))
-}
-
-function parseMeta(ast: SchemaAST.AST): [SchemaAST.SchemaIdAnnotation | undefined, Record<string | symbol, unknown>] {
-  const jsonSchema = SchemaAST.getJSONSchemaAnnotation(ast).pipe(
-    Option.filter(Predicate.isReadonlyRecord),
-    Option.getOrUndefined
-  )
-  const schemaId = Option.getOrElse(SchemaAST.getSchemaIdAnnotation(ast), () => undefined)
-  const schemaParams = Option.fromNullable(schemaId).pipe(
-    Option.map((id) => ast.annotations[id]),
-    Option.filter(Predicate.isReadonlyRecord),
-    Option.getOrUndefined
-  )
-  return [schemaId, { ...schemaParams, ...jsonSchema }]
-}
-
-/** @internal */
-export const getDescription = wrapGetDescription(
-  (ast, description) => {
-    const annotation = getArbitraryAnnotation(ast)
-    if (Option.isSome(annotation)) {
-      return {
-        ...description,
-        annotations: [...description.annotations, annotation.value]
-      }
-    }
-    return description
-  },
-  (ast, path) => {
-    const [schemaId, meta] = parseMeta(ast)
-    switch (ast._tag) {
-      case "Refinement": {
-        const from = getDescription(ast.from, path)
-        switch (from._tag) {
-          case "StringKeyword":
-            return {
-              ...from,
-              constraints: [...from.constraints, makeStringConstraints(meta)],
-              refinements: [...from.refinements, ast]
-            }
-          case "NumberKeyword": {
-            const c = schemaId === schemaId_.NonNaNSchemaId ?
-              makeNumberConstraints({ noNaN: true }) :
-              schemaId === schemaId_.FiniteSchemaId || schemaId === schemaId_.JsonNumberSchemaId ?
-              makeNumberConstraints({ noDefaultInfinity: true, noNaN: true }) :
-              makeNumberConstraints({
-                isInteger: "type" in meta && meta.type === "integer",
-                noNaN: undefined,
-                noDefaultInfinity: undefined,
-                min: meta.exclusiveMinimum ?? meta.minimum,
-                minExcluded: "exclusiveMinimum" in meta ? true : undefined,
-                max: meta.exclusiveMaximum ?? meta.maximum,
-                maxExcluded: "exclusiveMaximum" in meta ? true : undefined
-              })
-            return {
-              ...from,
-              constraints: [...from.constraints, c],
-              refinements: [...from.refinements, ast]
-            }
-          }
-          case "BigIntKeyword": {
-            const c = getASTConstraints(ast)
-            return {
-              ...from,
-              constraints: c !== undefined ? [...from.constraints, makeBigIntConstraints(c)] : from.constraints,
-              refinements: [...from.refinements, ast]
-            }
-          }
-          case "TupleType":
-            return {
-              ...from,
-              constraints: [
-                ...from.constraints,
-                makeArrayConstraints({
-                  minLength: meta.minItems,
-                  maxLength: meta.maxItems
-                })
-              ],
-              refinements: [...from.refinements, ast]
-            }
-          case "DateFromSelf":
-            return {
-              ...from,
-              constraints: [...from.constraints, makeDateConstraints(meta)],
-              refinements: [...from.refinements, ast]
-            }
-          default:
-            return {
-              ...from,
-              refinements: [...from.refinements, ast]
-            }
-        }
-      }
-      case "Declaration": {
-        if (schemaId === schemaId_.DateFromSelfSchemaId) {
-          return {
-            _tag: "DateFromSelf",
-            constraints: [makeDateConstraints(meta)],
-            path,
-            refinements: [],
-            annotations: []
-          }
-        }
-        return {
-          _tag: "Declaration",
-          typeParameters: ast.typeParameters.map((ast) => getDescription(ast, path)),
-          path,
-          refinements: [],
-          annotations: [],
-          ast
-        }
-      }
-      case "Literal": {
-        return {
-          _tag: "Literal",
-          literal: ast.literal,
-          path,
-          refinements: [],
-          annotations: []
-        }
-      }
-      case "UniqueSymbol": {
-        return {
-          _tag: "UniqueSymbol",
-          symbol: ast.symbol,
-          path,
-          refinements: [],
-          annotations: []
-        }
-      }
-      case "Enums": {
-        return {
-          _tag: "Enums",
-          enums: ast.enums,
-          path,
-          refinements: [],
-          annotations: [],
-          ast
-        }
-      }
-      case "TemplateLiteral": {
-        return {
-          _tag: "TemplateLiteral",
-          head: ast.head,
-          spans: ast.spans.map((span) => ({
-            description: getDescription(span.type, path),
-            literal: span.literal
-          })),
-          path,
-          refinements: [],
-          annotations: []
-        }
-      }
-      case "StringKeyword":
-        return {
-          _tag: "StringKeyword",
-          constraints: [],
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "NumberKeyword":
-        return {
-          _tag: "NumberKeyword",
-          constraints: [],
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "BigIntKeyword":
-        return {
-          _tag: "BigIntKeyword",
-          constraints: [],
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "TupleType":
-        return {
-          _tag: "TupleType",
-          constraints: [],
-          elements: ast.elements.map((element, i) => ({
-            isOptional: element.isOptional,
-            description: getDescription(element.type, [...path, i])
-          })),
-          rest: ast.rest.map((element, i) => getDescription(element.type, [...path, i])),
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "TypeLiteral":
-        return {
-          _tag: "TypeLiteral",
-          propertySignatures: ast.propertySignatures.map((ps) => ({
-            isOptional: ps.isOptional,
-            name: ps.name,
-            value: getDescription(ps.type, [...path, ps.name])
-          })),
-          indexSignatures: ast.indexSignatures.map((is) => ({
-            parameter: getDescription(is.parameter, path),
-            value: getDescription(is.type, path)
-          })),
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "Union":
-        return {
-          _tag: "Union",
-          members: ast.types.map((member, i) => getDescription(member, [...path, i])),
-          path,
-          refinements: [],
-          annotations: []
-        }
-      case "Suspend": {
-        const memoId = idMemoMap.get(ast)
-        if (memoId !== undefined) {
-          return {
-            _tag: "Ref",
-            id: memoId,
-            ast,
-            path,
-            refinements: [],
-            annotations: []
-          }
-        }
-        counter++
-        const id = `__id-${counter}__`
-        idMemoMap.set(ast, id)
-        return {
-          _tag: "Suspend",
-          id,
-          ast,
-          description: () => getDescription(ast.f(), path),
-          path,
-          refinements: [],
-          annotations: []
-        }
-      }
-      case "Transformation":
-        return getDescription(ast.to, path)
-      case "NeverKeyword":
-        return {
-          _tag: "NeverKeyword",
-          path,
-          refinements: [],
-          annotations: [],
-          ast
-        }
-      default: {
-        return {
-          _tag: "Keyword",
-          value: ast._tag,
-          path,
-          refinements: [],
-          annotations: []
-        }
-      }
-    }
-  }
-)
-
-function getMax(n1: Date | undefined, n2: Date | undefined): Date | undefined
-function getMax(n1: bigint | undefined, n2: bigint | undefined): bigint | undefined
-function getMax(n1: number | undefined, n2: number | undefined): number | undefined
-function getMax(
-  n1: bigint | number | Date | undefined,
-  n2: bigint | number | Date | undefined
-): bigint | number | Date | undefined {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1
-}
-
-function getMin(n1: Date | undefined, n2: Date | undefined): Date | undefined
-function getMin(n1: bigint | undefined, n2: bigint | undefined): bigint | undefined
-function getMin(n1: number | undefined, n2: number | undefined): number | undefined
-function getMin(
-  n1: bigint | number | Date | undefined,
-  n2: bigint | number | Date | undefined
-): bigint | number | Date | undefined {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2
-}
-
-const getOr = (a: boolean | undefined, b: boolean | undefined): boolean | undefined => {
-  return a === undefined ? b : b === undefined ? a : a || b
-}
-
-function mergePattern(pattern1: string | undefined, pattern2: string | undefined): string | undefined {
-  if (pattern1 === undefined) {
-    return pattern2
-  }
-  if (pattern2 === undefined) {
-    return pattern1
-  }
-  return `(?:${pattern1})|(?:${pattern2})`
-}
-
-function mergeStringConstraints(c1: StringConstraints, c2: StringConstraints): StringConstraints {
-  return makeStringConstraints({
-    minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
-    maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength),
-    pattern: mergePattern(c1.pattern, c2.pattern)
-  })
-}
-
-function buildStringConstraints(description: StringKeyword): StringConstraints | undefined {
-  return description.constraints.length === 0
-    ? undefined
-    : description.constraints.reduce(mergeStringConstraints)
-}
-
-function mergeNumberConstraints(c1: NumberConstraints, c2: NumberConstraints): NumberConstraints {
-  return makeNumberConstraints({
-    isInteger: c1.isInteger || c2.isInteger,
-    min: getMax(c1.constraints.min, c2.constraints.min),
-    minExcluded: getOr(c1.constraints.minExcluded, c2.constraints.minExcluded),
-    max: getMin(c1.constraints.max, c2.constraints.max),
-    maxExcluded: getOr(c1.constraints.maxExcluded, c2.constraints.maxExcluded),
-    noNaN: getOr(c1.constraints.noNaN, c2.constraints.noNaN),
-    noDefaultInfinity: getOr(c1.constraints.noDefaultInfinity, c2.constraints.noDefaultInfinity)
-  })
-}
-
-function buildNumberConstraints(description: NumberKeyword): NumberConstraints | undefined {
-  return description.constraints.length === 0
-    ? undefined
-    : description.constraints.reduce(mergeNumberConstraints)
-}
-
-function mergeBigIntConstraints(c1: BigIntConstraints, c2: BigIntConstraints): BigIntConstraints {
-  return makeBigIntConstraints({
-    min: getMax(c1.constraints.min, c2.constraints.min),
-    max: getMin(c1.constraints.max, c2.constraints.max)
-  })
-}
-
-function buildBigIntConstraints(description: BigIntKeyword): BigIntConstraints | undefined {
-  return description.constraints.length === 0
-    ? undefined
-    : description.constraints.reduce(mergeBigIntConstraints)
-}
-
-function mergeDateConstraints(c1: DateConstraints, c2: DateConstraints): DateConstraints {
-  return makeDateConstraints({
-    min: getMax(c1.constraints.min, c2.constraints.min),
-    max: getMin(c1.constraints.max, c2.constraints.max),
-    noInvalidDate: getOr(c1.constraints.noInvalidDate, c2.constraints.noInvalidDate)
-  })
-}
-
-function buildDateConstraints(description: DateFromSelf): DateConstraints | undefined {
-  return description.constraints.length === 0
-    ? undefined
-    : description.constraints.reduce(mergeDateConstraints)
-}
-
-const constArrayConstraints = makeArrayConstraints({})
-
-function mergeArrayConstraints(c1: ArrayConstraints, c2: ArrayConstraints): ArrayConstraints {
-  return makeArrayConstraints({
-    minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
-    maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
-  })
-}
-
-function buildArrayConstraints(description: TupleType): ArrayConstraints | undefined {
-  return description.constraints.length === 0
-    ? undefined
-    : description.constraints.reduce(mergeArrayConstraints)
-}
-
-const arbitraryMemoMap = globalValue(
-  Symbol.for("effect/Arbitrary/arbitraryMemoMap"),
-  () => new WeakMap<SchemaAST.AST, LazyArbitrary<any>>()
-)
-
-function applyFilters(filters: ReadonlyArray<Predicate.Predicate<any>>, arb: LazyArbitrary<any>): LazyArbitrary<any> {
-  return (fc) => filters.reduce((arb, filter) => arb.filter(filter), arb(fc))
-}
-
-function absurd(message: string): LazyArbitrary<any> {
-  return () => {
-    throw new Error(message)
-  }
-}
-
-function getContextConstraints(description: Description): ArbitraryGenerationContext["constraints"] {
-  switch (description._tag) {
-    case "StringKeyword":
-      return buildStringConstraints(description)
-    case "NumberKeyword":
-      return buildNumberConstraints(description)
-    case "BigIntKeyword":
-      return buildBigIntConstraints(description)
-    case "DateFromSelf":
-      return buildDateConstraints(description)
-    case "TupleType":
-      return buildArrayConstraints(description)
-  }
-}
-
-function wrapGo(
-  f: (description: Description, ctx: ArbitraryGenerationContext, lazyArb: LazyArbitrary<any>) => LazyArbitrary<any>,
-  g: (description: Description, ctx: ArbitraryGenerationContext) => LazyArbitrary<any>
-): (description: Description, ctx: ArbitraryGenerationContext) => LazyArbitrary<any> {
-  return (description, ctx) => f(description, ctx, g(description, ctx))
-}
-
-const go = wrapGo(
-  (description, ctx, lazyArb) => {
-    const annotation: ArbitraryAnnotation<any, any> | undefined =
-      description.annotations[description.annotations.length - 1]
-
-    // error handling
-    if (annotation === undefined) {
-      switch (description._tag) {
-        case "Declaration":
-        case "NeverKeyword":
-          throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(description.path, description.ast))
-        case "Enums":
-          if (description.enums.length === 0) {
-            throw new Error(errors_.getArbitraryEmptyEnumErrorMessage(description.path))
-          }
-      }
-    }
-
-    const filters = description.refinements.map((ast) => (a: any) =>
-      Option.isNone(ast.filter(a, SchemaAST.defaultParseOption, ast))
-    )
-    if (annotation === undefined) {
-      return applyFilters(filters, lazyArb)
-    }
-
-    const constraints = getContextConstraints(description)
-    if (constraints !== undefined) {
-      ctx = { ...ctx, constraints }
-    }
-
-    if (description._tag === "Declaration") {
-      return applyFilters(filters, annotation(...description.typeParameters.map((p) => go(p, ctx)), ctx))
-    }
-    if (description.refinements.length > 0) {
-      // TODO(4.0): remove the `lazyArb` parameter
-      return applyFilters(filters, annotation(lazyArb, ctx))
-    }
-    return annotation(ctx)
-  },
-  (description, ctx) => {
-    switch (description._tag) {
-      case "DateFromSelf": {
-        const constraints = buildDateConstraints(description)
-        return (fc) => fc.date(constraints?.constraints)
-      }
-      case "Declaration":
-      case "NeverKeyword":
-        return absurd(`BUG: cannot generate an arbitrary for ${description._tag}`)
-      case "Literal":
-        return (fc) => fc.constant(description.literal)
-      case "UniqueSymbol":
-        return (fc) => fc.constant(description.symbol)
-      case "Keyword": {
-        switch (description.value) {
-          case "UndefinedKeyword":
-            return (fc) => fc.constant(undefined)
-          case "VoidKeyword":
-          case "UnknownKeyword":
-          case "AnyKeyword":
-            return (fc) => fc.anything()
-          case "BooleanKeyword":
-            return (fc) => fc.boolean()
-          case "SymbolKeyword":
-            return (fc) => fc.string().map((s) => Symbol.for(s))
-          case "ObjectKeyword":
-            return (fc) => fc.oneof(fc.object(), fc.array(fc.anything()))
-        }
-      }
-      case "Enums":
-        return (fc) => fc.oneof(...description.enums.map(([_, value]) => fc.constant(value)))
-      case "TemplateLiteral": {
-        return (fc) => {
-          const string = fc.string({ maxLength: 5 })
-          const number = fc.float({ noDefaultInfinity: true, noNaN: true })
-
-          const getTemplateLiteralArb = (description: TemplateLiteral) => {
-            const components: Array<FastCheck.Arbitrary<string | number>> = description.head !== ""
-              ? [fc.constant(description.head)]
-              : []
-
-            const getTemplateLiteralSpanTypeArb = (
-              description: Description
-            ): FastCheck.Arbitrary<string | number> => {
-              switch (description._tag) {
-                case "StringKeyword":
-                  return string
-                case "NumberKeyword":
-                  return number
-                case "Literal":
-                  return fc.constant(String(description.literal))
-                case "Union":
-                  return fc.oneof(...description.members.map(getTemplateLiteralSpanTypeArb))
-                case "TemplateLiteral":
-                  return getTemplateLiteralArb(description)
-                default:
-                  return fc.constant("")
-              }
-            }
-
-            description.spans.forEach((span) => {
-              components.push(getTemplateLiteralSpanTypeArb(span.description))
-              if (span.literal !== "") {
-                components.push(fc.constant(span.literal))
-              }
-            })
-
-            return fc.tuple(...components).map((spans) => spans.join(""))
-          }
-
-          return getTemplateLiteralArb(description)
-        }
-      }
-      case "StringKeyword": {
-        const constraints = buildStringConstraints(description)
-        const pattern = constraints?.pattern
-        return pattern !== undefined ?
-          (fc) => fc.stringMatching(new RegExp(pattern)) :
-          (fc) => fc.string(constraints?.constraints)
-      }
-      case "NumberKeyword": {
-        const constraints = buildNumberConstraints(description)
-        return constraints?.isInteger ?
-          (fc) => fc.integer(constraints.constraints) :
-          (fc) => fc.float(constraints?.constraints)
-      }
-      case "BigIntKeyword": {
-        const constraints = buildBigIntConstraints(description)
-        return (fc) => fc.bigInt(constraints?.constraints ?? {})
-      }
-      case "TupleType": {
-        const elements: Array<LazyArbitrary<any>> = []
-        let hasOptionals = false
-        for (const element of description.elements) {
-          elements.push(go(element.description, ctx))
-          if (element.isOptional) {
-            hasOptionals = true
-          }
-        }
-        const rest = description.rest.map((d) => go(d, ctx))
-        return (fc) => {
-          // ---------------------------------------------
-          // handle elements
-          // ---------------------------------------------
-          let output = fc.tuple(...elements.map((arb) => arb(fc)))
-          if (hasOptionals) {
-            const indexes = fc.tuple(
-              ...description.elements.map((element) => element.isOptional ? fc.boolean() : fc.constant(true))
-            )
-            output = output.chain((tuple) =>
-              indexes.map((booleans) => {
-                for (const [i, b] of booleans.reverse().entries()) {
-                  if (!b) {
-                    tuple.splice(booleans.length - i, 1)
-                  }
-                }
-                return tuple
-              })
-            )
-          }
-
-          // ---------------------------------------------
-          // handle rest element
-          // ---------------------------------------------
-          if (Arr.isNonEmptyReadonlyArray(rest)) {
-            const constraints = buildArrayConstraints(description) ?? constArrayConstraints
-            const [head, ...tail] = rest
-            const item = head(fc)
-            output = output.chain((as) => {
-              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.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
-            // ---------------------------------------------
-            for (let j = 0; j < tail.length; j++) {
-              output = output.chain((as) => tail[j](fc).map((a) => [...as, a]))
-            }
-          }
-
-          return output
-        }
-      }
-      case "TypeLiteral": {
-        const propertySignatures: Array<LazyArbitrary<any>> = []
-        const requiredKeys: Array<PropertyKey> = []
-        for (const ps of description.propertySignatures) {
-          if (!ps.isOptional) {
-            requiredKeys.push(ps.name)
-          }
-          propertySignatures.push(go(ps.value, ctx))
-        }
-        const indexSignatures = description.indexSignatures.map((is) =>
-          [go(is.parameter, ctx), go(is.value, ctx)] as const
-        )
-        return (fc) => {
-          const pps: any = {}
-          for (let i = 0; i < propertySignatures.length; i++) {
-            const ps = description.propertySignatures[i]
-            pps[ps.name] = propertySignatures[i](fc)
-          }
-          let output = fc.record<any, any>(pps, { requiredKeys })
-          // ---------------------------------------------
-          // handle index signatures
-          // ---------------------------------------------
-          for (let i = 0; i < indexSignatures.length; i++) {
-            const key = indexSignatures[i][0](fc)
-            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, { maxLength: 2 }) :
-                fc.array(item)
-              return arr.map((tuples) => ({ ...Object.fromEntries(tuples), ...o }))
-            })
-          }
-
-          return output
-        }
-      }
-      case "Union": {
-        const members = description.members.map((member) => go(member, ctx))
-        return (fc) => fc.oneof(...members.map((arb) => arb(fc)))
-      }
-      case "Suspend": {
-        const memo = arbitraryMemoMap.get(description.ast)
-        if (memo) {
-          return memo
-        }
-        if (ctx.depthIdentifier === undefined) {
-          ctx = { ...ctx, depthIdentifier: description.id }
-        }
-        const get = util_.memoizeThunk(() => {
-          return go(description.description(), ctx)
-        })
-        const out: LazyArbitrary<any> = (fc) => fc.constant(null).chain(() => get()(fc))
-        arbitraryMemoMap.set(description.ast, out)
-        return out
-      }
-      case "Ref": {
-        const memo = arbitraryMemoMap.get(description.ast)
-        if (memo) {
-          return memo
-        }
-        throw new Error(`BUG: Ref ${JSON.stringify(description.id)} not found`)
-      }
-    }
-  }
-)
-
-function subtractElementsLength(
-  constraints: FastCheck.ArrayConstraints,
-  len: number
-): FastCheck.ArrayConstraints {
-  if (len === 0 || (constraints.minLength === undefined && constraints.maxLength === undefined)) {
-    return constraints
-  }
-  const out = { ...constraints }
-  if (out.minLength !== undefined) {
-    out.minLength = Math.max(out.minLength - len, 0)
-  }
-  if (out.maxLength !== undefined) {
-    out.maxLength = Math.max(out.maxLength - len, 0)
-  }
-  return out
-}
-
-const getSuspendedArray = (
-  fc: typeof FastCheck,
-  depthIdentifier: string,
-  maxDepth: number,
-  item: FastCheck.Arbitrary<any>,
-  constraints: FastCheck.ArrayConstraints
-) => {
-  // 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, constraints)
-  )
-}