effect 3.14.0 → 3.14.2

package/dist/esm/Arbitrary.js

@@ -9,16 +9,19 @@ 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 * as AST from "./SchemaAST.js";
+import * as SchemaAST from "./SchemaAST.js";
 /**
  * Returns a LazyArbitrary for the `A` type of the provided schema.
  *
  * @category arbitrary
  * @since 3.10.0
  */
-export const makeLazy = schema => go(schema.ast, {
-  maxDepth: 2
-}, []);
+export const makeLazy = schema => {
+  const description = getDescription(schema.ast, []);
+  return go(description, {
+    maxDepth: 2
+  });
+};
 /**
  * Returns a fast-check Arbitrary for the `A` type of the provided schema.
  *
@@ -26,60 +29,6 @@ export const makeLazy = schema => go(schema.ast, {
  * @since 3.10.0
  */
 export const make = schema => makeLazy(schema)(FastCheck);
-const getArbitraryAnnotation = /*#__PURE__*/AST.getAnnotation(AST.ArbitraryAnnotationId);
-/**
- * Represents an arbitrary with optional filters.
- */
-class Succeed {
-  lazyArbitrary;
-  filters;
-  _tag = "Succeed";
-  constructor(lazyArbitrary, filters = []) {
-    this.lazyArbitrary = lazyArbitrary;
-    this.filters = filters;
-  }
-  toLazyArbitrary() {
-    return fc => {
-      let out = this.lazyArbitrary(fc);
-      for (const f of this.filters) {
-        out = out.filter(f);
-      }
-      return out;
-    };
-  }
-}
-/**
- * Represents a deferred arbitrary value generator with optional filters.
- */
-class Deferred {
-  config;
-  filters;
-  _tag = "Deferred";
-  constructor(config, filters = []) {
-    this.config = config;
-    this.filters = filters;
-  }
-  toLazyArbitrary(ctx, path) {
-    const config = this.config;
-    switch (config._tag) {
-      case "StringConstraints":
-        {
-          const pattern = config.pattern;
-          return pattern !== undefined ? fc => fc.stringMatching(new RegExp(pattern)) : fc => fc.string(config.constraints);
-        }
-      case "NumberConstraints":
-        {
-          return config.isInteger ? fc => fc.integer(config.constraints) : fc => fc.float(config.constraints);
-        }
-      case "BigIntConstraints":
-        return fc => fc.bigInt(config.constraints);
-      case "DateConstraints":
-        return fc => fc.date(config.constraints);
-      case "ArrayConstraints":
-        return goTupleType(config.ast, ctx, path, config.constraints);
-    }
-  }
-}
 /** @internal */
 export const makeStringConstraints = options => {
   const out = {
@@ -156,9 +105,7 @@ export const makeArrayConstraints = options => {
 export const makeDateConstraints = options => {
   const out = {
     _tag: "DateConstraints",
-    constraints: {
-      noInvalidDate: options.noInvalidDate ?? false
-    }
+    constraints: {}
   };
   if (Predicate.isDate(options.min)) {
     out.constraints.min = options.min;
@@ -166,54 +113,14 @@ export const makeDateConstraints = options => {
   if (Predicate.isDate(options.max)) {
     out.constraints.max = options.max;
   }
-  return out;
-};
-const makeArrayConfig = (options, ast) => {
-  return {
-    ast,
-    ...makeArrayConstraints(options)
-  };
-};
-const arbitraryMemoMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Arbitrary/arbitraryMemoMap"), () => new WeakMap());
-const go = (ast, ctx, path) => {
-  const hook = getArbitraryAnnotation(ast);
-  if (Option.isSome(hook)) {
-    switch (ast._tag) {
-      case "Declaration":
-        return hook.value(...ast.typeParameters.map(p => go(p, ctx, path)), ctx);
-      case "Refinement":
-        {
-          const op = toOp(ast, ctx, path);
-          ctx = op._tag === "Deferred" ? {
-            ...ctx,
-            constraints: op.config
-          } : ctx;
-          const from = go(ast.from, ctx, path);
-          return new Succeed(hook.value(from, ctx), op.filters).toLazyArbitrary();
-        }
-      default:
-        return hook.value(ctx);
-    }
-  }
-  if (AST.isDeclaration(ast)) {
-    throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(path, ast));
-  }
-  const op = toOp(ast, ctx, path);
-  switch (op._tag) {
-    case "Succeed":
-      return op.toLazyArbitrary();
-    case "Deferred":
-      return new Succeed(op.toLazyArbitrary(ctx, path), op.filters).toLazyArbitrary();
+  if (Predicate.isBoolean(options.noInvalidDate)) {
+    out.constraints.noInvalidDate = options.noInvalidDate;
   }
+  return out;
 };
-const constStringConstraints = /*#__PURE__*/makeStringConstraints({});
-const constNumberConstraints = /*#__PURE__*/makeNumberConstraints({});
-const constBigIntConstraints = /*#__PURE__*/makeBigIntConstraints({});
-const defaultSuspendedArrayConstraints = {
-  maxLength: 2
-};
+const getArbitraryAnnotation = /*#__PURE__*/SchemaAST.getAnnotation(SchemaAST.ArbitraryAnnotationId);
 const getASTConstraints = ast => {
-  const TypeAnnotationId = ast.annotations[AST.SchemaIdAnnotationId];
+  const TypeAnnotationId = ast.annotations[SchemaAST.SchemaIdAnnotationId];
   if (Predicate.isPropertyKey(TypeAnnotationId)) {
     const out = ast.annotations[TypeAnnotationId];
     if (Predicate.isReadonlyRecord(out)) {
@@ -221,122 +128,573 @@ const getASTConstraints = ast => {
     }
   }
 };
+const idMemoMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Arbitrary/IdMemoMap"), () => new Map());
+let counter = 0;
+function wrapGetDescription(f, g) {
+  return (ast, path) => f(ast, g(ast, path));
+}
+function parseMeta(ast) {
+  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 toOp = (ast, ctx, path) => {
+export const getDescription = /*#__PURE__*/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
+              }) : makeNumberConstraints({
+                isInteger: "type" in meta && meta.type === "integer",
+                noNaN: "type" in meta && meta.type === "number" ? true : undefined,
+                noDefaultInfinity: "type" in meta && meta.type === "number" ? true : 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":
       {
-        const TypeAnnotationId = ast.annotations[AST.SchemaIdAnnotationId];
-        if (TypeAnnotationId === schemaId_.DateFromSelfSchemaId) {
-          const c = getASTConstraints(ast);
-          if (c !== undefined) {
-            return new Deferred(makeDateConstraints(c));
-          }
+        if (schemaId === schemaId_.DateFromSelfSchemaId) {
+          return {
+            _tag: "DateFromSelf",
+            constraints: [makeDateConstraints(meta)],
+            path,
+            refinements: [],
+            annotations: []
+          };
         }
-        return new Succeed(go(ast, ctx, path));
+        return {
+          _tag: "Declaration",
+          typeParameters: ast.typeParameters.map(ast => getDescription(ast, path)),
+          path,
+          refinements: [],
+          annotations: [],
+          ast
+        };
       }
     case "Literal":
-      return new Succeed(fc => fc.constant(ast.literal));
+      {
+        return {
+          _tag: "Literal",
+          literal: ast.literal,
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
     case "UniqueSymbol":
-      return new Succeed(fc => fc.constant(ast.symbol));
-    case "UndefinedKeyword":
-      return new Succeed(fc => fc.constant(undefined));
+      {
+        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":
-      throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(path, ast));
-    case "VoidKeyword":
-    case "UnknownKeyword":
-    case "AnyKeyword":
-      return new Succeed(fc => fc.anything());
+      return {
+        _tag: "NeverKeyword",
+        path,
+        refinements: [],
+        annotations: [],
+        ast
+      };
+    default:
+      {
+        return {
+          _tag: "Keyword",
+          value: ast._tag,
+          path,
+          refinements: [],
+          annotations: []
+        };
+      }
+  }
+});
+function getMax(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1;
+}
+function getMin(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2;
+}
+const getOr = (a, b) => {
+  return a === undefined ? b : b === undefined ? a : a || b;
+};
+function mergePattern(pattern1, pattern2) {
+  if (pattern1 === undefined) {
+    return pattern2;
+  }
+  if (pattern2 === undefined) {
+    return pattern1;
+  }
+  return `(?:${pattern1})|(?:${pattern2})`;
+}
+function mergeStringConstraints(c1, c2) {
+  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) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeStringConstraints);
+}
+function mergeNumberConstraints(c1, c2) {
+  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) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeNumberConstraints);
+}
+function mergeBigIntConstraints(c1, c2) {
+  return makeBigIntConstraints({
+    min: getMax(c1.constraints.min, c2.constraints.min),
+    max: getMin(c1.constraints.max, c2.constraints.max)
+  });
+}
+function buildBigIntConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeBigIntConstraints);
+}
+function mergeDateConstraints(c1, c2) {
+  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) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeDateConstraints);
+}
+const constArrayConstraints = /*#__PURE__*/makeArrayConstraints({});
+function mergeArrayConstraints(c1, c2) {
+  return makeArrayConstraints({
+    minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
+    maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
+  });
+}
+function buildArrayConstraints(description) {
+  return description.constraints.length === 0 ? undefined : description.constraints.reduce(mergeArrayConstraints);
+}
+const arbitraryMemoMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Arbitrary/arbitraryMemoMap"), () => new WeakMap());
+function applyFilters(filters, arb) {
+  return fc => filters.reduce((arb, filter) => arb.filter(filter), arb(fc));
+}
+function absurd(message) {
+  return () => {
+    throw new Error(message);
+  };
+}
+function getContextConstraints(description) {
+  switch (description._tag) {
     case "StringKeyword":
-      return new Deferred(constStringConstraints);
+      return buildStringConstraints(description);
     case "NumberKeyword":
-      return new Deferred(constNumberConstraints);
-    case "BooleanKeyword":
-      return new Succeed(fc => fc.boolean());
+      return buildNumberConstraints(description);
     case "BigIntKeyword":
-      return new Deferred(constBigIntConstraints);
-    case "SymbolKeyword":
-      return new Succeed(fc => fc.string().map(s => Symbol.for(s)));
-    case "ObjectKeyword":
-      return new Succeed(fc => fc.oneof(fc.object(), fc.array(fc.anything())));
-    case "Enums":
+      return buildBigIntConstraints(description);
+    case "DateFromSelf":
+      return buildDateConstraints(description);
+    case "TupleType":
+      return buildArrayConstraints(description);
+  }
+}
+function wrapGo(f, g) {
+  return (description, ctx) => f(description, ctx, g(description, ctx));
+}
+const go = /*#__PURE__*/wrapGo((description, ctx, lazyArb) => {
+  const annotation = 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 => 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":
       {
-        if (ast.enums.length === 0) {
-          throw new Error(errors_.getArbitraryEmptyEnumErrorMessage(path));
+        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()));
         }
-        return new Succeed(fc => fc.oneof(...ast.enums.map(([_, value]) => fc.constant(value))));
       }
+    case "Enums":
+      return fc => fc.oneof(...description.enums.map(([_, value]) => fc.constant(value)));
     case "TemplateLiteral":
-      return new Succeed(fc => {
-        const string = fc.string({
-          maxLength: 5
-        });
-        const number = fc.float({
-          noDefaultInfinity: true,
-          noNaN: true
-        });
-        const getTemplateLiteralArb = ast => {
-          const components = ast.head !== "" ? [fc.constant(ast.head)] : [];
-          const getTemplateLiteralSpanTypeArb = ast => {
-            switch (ast._tag) {
-              case "StringKeyword":
-                return string;
-              case "NumberKeyword":
-                return number;
-              case "Literal":
-                return fc.constant(String(ast.literal));
-              case "Union":
-                return fc.oneof(...ast.types.map(getTemplateLiteralSpanTypeArb));
-              case "TemplateLiteral":
-                return getTemplateLiteralArb(ast);
-            }
-          };
-          ast.spans.forEach(span => {
-            components.push(getTemplateLiteralSpanTypeArb(span.type));
-            if (span.literal !== "") {
-              components.push(fc.constant(span.literal));
-            }
+      {
+        return fc => {
+          const string = fc.string({
+            maxLength: 5
+          });
+          const number = fc.float({
+            noDefaultInfinity: true,
+            noNaN: true
           });
-          return fc.tuple(...components).map(spans => spans.join(""));
+          const getTemplateLiteralArb = description => {
+            const components = description.head !== "" ? [fc.constant(description.head)] : [];
+            const getTemplateLiteralSpanTypeArb = description => {
+              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);
         };
-        return getTemplateLiteralArb(ast);
-      });
-    case "Refinement":
+      }
+    case "StringKeyword":
       {
-        const from = toOp(ast.from, ctx, path);
-        const filters = [...from.filters, a => Option.isNone(ast.filter(a, AST.defaultParseOption, ast))];
-        switch (from._tag) {
-          case "Succeed":
-            {
-              return new Succeed(from.lazyArbitrary, filters);
-            }
-          case "Deferred":
-            {
-              return new Deferred(merge(from.config, getRefinementConstraints(from.config._tag, ast)), filters);
-            }
-        }
+        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":
-      return new Deferred(makeArrayConfig({}, ast));
-    case "TypeLiteral":
       {
-        const propertySignaturesTypes = ast.propertySignatures.map(ps => go(ps.type, ctx, path.concat(ps.name)));
-        const indexSignatures = ast.indexSignatures.map(is => [go(is.parameter, ctx, path), go(is.type, ctx, path)]);
-        return new Succeed(fc => {
-          const arbs = {};
-          const requiredKeys = [];
+        const elements = [];
+        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 property signatures
+          // handle rest element
           // ---------------------------------------------
-          for (let i = 0; i < propertySignaturesTypes.length; i++) {
-            const ps = ast.propertySignatures[i];
-            const name = ps.name;
-            if (!ps.isOptional) {
-              requiredKeys.push(name);
+          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]));
             }
-            arbs[name] = propertySignaturesTypes[i](fc);
           }
-          let output = fc.record(arbs, {
+          return output;
+        };
+      }
+    case "TypeLiteral":
+      {
+        const propertySignatures = [];
+        const requiredKeys = [];
+        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)]);
+        return fc => {
+          const pps = {};
+          for (let i = 0; i < propertySignatures.length; i++) {
+            const ps = description.propertySignatures[i];
+            pps[ps.name] = propertySignatures[i](fc);
+          }
+          let output = fc.record(pps, {
             requiredKeys
           });
           // ---------------------------------------------
@@ -348,16 +706,18 @@ export const toOp = (ast, ctx, path) => {
             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, defaultSuspendedArrayConstraints) : fc.array(item);
+                         `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
@@ -365,237 +725,57 @@ export const toOp = (ast, ctx, path) => {
             });
           }
           return output;
-        });
+        };
       }
     case "Union":
       {
-        const types = ast.types.map(member => go(member, ctx, path));
-        return new Succeed(fc => fc.oneof(...types.map(arb => arb(fc))));
+        const members = description.members.map(member => go(member, ctx));
+        return fc => fc.oneof(...members.map(arb => arb(fc)));
       }
     case "Suspend":
       {
-        const memo = arbitraryMemoMap.get(ast);
+        const memo = arbitraryMemoMap.get(description.ast);
         if (memo) {
-          return new Succeed(memo);
+          return memo;
+        }
+        if (ctx.depthIdentifier === undefined) {
+          ctx = {
+            ...ctx,
+            depthIdentifier: description.id
+          };
         }
         const get = util_.memoizeThunk(() => {
-          return go(ast.f(), getSuspendedContext(ctx, ast), path);
+          return go(description.description(), ctx);
         });
         const out = fc => fc.constant(null).chain(() => get()(fc));
-        arbitraryMemoMap.set(ast, out);
-        return new Succeed(out);
+        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`);
       }
-    case "Transformation":
-      return toOp(ast.to, ctx, path);
   }
-};
-function subtractElementsLength(constraints, elementsLength) {
-  if (elementsLength === 0 || constraints.minLength === undefined && constraints.maxLength === undefined) {
+});
+function subtractElementsLength(constraints, len) {
+  if (len === 0 || constraints.minLength === undefined && constraints.maxLength === undefined) {
     return constraints;
   }
   const out = {
     ...constraints
   };
   if (out.minLength !== undefined) {
-    out.minLength = Math.max(out.minLength - elementsLength, 0);
+    out.minLength = Math.max(out.minLength - len, 0);
   }
   if (out.maxLength !== undefined) {
-    out.maxLength = Math.max(out.maxLength - elementsLength, 0);
+    out.maxLength = Math.max(out.maxLength - len, 0);
   }
   return out;
 }
-const goTupleType = (ast, ctx, path, constraints) => {
-  const elements = [];
-  let hasOptionals = false;
-  let i = 0;
-  for (const element of ast.elements) {
-    elements.push(go(element.type, ctx, path.concat(i++)));
-    if (element.isOptional) {
-      hasOptionals = true;
-    }
-  }
-  const rest = ast.rest.map(annotatedAST => go(annotatedAST.type, ctx, path));
-  return fc => {
-    // ---------------------------------------------
-    // handle elements
-    // ---------------------------------------------
-    let output = fc.tuple(...elements.map(arb => arb(fc)));
-    if (hasOptionals) {
-      const indexes = fc.tuple(...ast.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 [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, 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;
-  };
-};
-const getRefinementConstraints = (_tag, ast) => {
-  const TypeAnnotationId = ast.annotations[AST.SchemaIdAnnotationId];
-  const jsonSchema = Option.getOrElse(AST.getJSONSchemaAnnotation(ast), () => ({}));
-  switch (_tag) {
-    case "StringConstraints":
-      return makeStringConstraints(jsonSchema);
-    case "NumberConstraints":
-      {
-        if (TypeAnnotationId === schemaId_.NonNaNSchemaId) {
-          return makeNumberConstraints({
-            noNaN: true
-          });
-        } else {
-          return makeNumberConstraints({
-            isInteger: "type" in jsonSchema && jsonSchema.type === "integer",
-            noNaN: "type" in jsonSchema && jsonSchema.type === "number" ? true : undefined,
-            noDefaultInfinity: "type" in jsonSchema && jsonSchema.type === "number" ? true : undefined,
-            min: jsonSchema.exclusiveMinimum ?? jsonSchema.minimum,
-            minExcluded: "exclusiveMinimum" in jsonSchema ? true : undefined,
-            max: jsonSchema.exclusiveMaximum ?? jsonSchema.maximum,
-            maxExcluded: "exclusiveMaximum" in jsonSchema ? true : undefined
-          });
-        }
-      }
-    case "BigIntConstraints":
-      {
-        const c = getASTConstraints(ast);
-        return c !== undefined ? makeBigIntConstraints(c) : undefined;
-      }
-    case "DateConstraints":
-      {
-        const c = getASTConstraints(ast);
-        return c !== undefined ? makeDateConstraints(c) : undefined;
-      }
-    case "ArrayConstraints":
-      return makeArrayConstraints({
-        minLength: jsonSchema.minItems,
-        maxLength: jsonSchema.maxItems
-      });
-  }
-};
-function getMax(n1, n2) {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1;
-}
-function getMin(n1, n2) {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2;
-}
-const getOr = (a, b) => {
-  return a === undefined ? b : b === undefined ? a : a || b;
-};
-function mergePattern(pattern1, pattern2) {
-  if (pattern1 === undefined) {
-    return pattern2;
-  }
-  if (pattern2 === undefined) {
-    return pattern1;
-  }
-  return `(?:${pattern1})|(?:${pattern2})`;
-}
-const merge = (c1, c2) => {
-  if (c2) {
-    switch (c1._tag) {
-      case "StringConstraints":
-        {
-          if (c2._tag === "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)
-            });
-          }
-          break;
-        }
-      case "NumberConstraints":
-        {
-          if (c2._tag === "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)
-            });
-          }
-          break;
-        }
-      case "BigIntConstraints":
-        {
-          if (c2._tag === "BigIntConstraints") {
-            return makeBigIntConstraints({
-              min: getMax(c1.constraints.min, c2.constraints.min),
-              max: getMin(c1.constraints.max, c2.constraints.max)
-            });
-          }
-          break;
-        }
-      case "DateConstraints":
-        {
-          if (c2._tag === "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)
-            });
-          }
-          break;
-        }
-      case "ArrayConstraints":
-        {
-          if (c2._tag === "ArrayConstraints") {
-            return makeArrayConfig({
-              minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
-              maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
-            }, c1.ast);
-          }
-          break;
-        }
-    }
-  }
-  return c1;
-};
 const getSuspendedArray = (fc, depthIdentifier, maxDepth, item, constraints) => {
   // 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
@@ -612,14 +792,4 @@ const getSuspendedArray = (fc, depthIdentifier, maxDepth, item, constraints) =>
     depthIdentifier
   }, fc.constant([]), fc.array(item, constraints));
 };
-const getSuspendedContext = (ctx, ast) => {
-  if (ctx.depthIdentifier !== undefined) {
-    return ctx;
-  }
-  const depthIdentifier = AST.getIdentifierAnnotation(ast).pipe(Option.orElse(() => AST.getIdentifierAnnotation(ast.f())), Option.getOrElse(() => "SuspendDefaultDepthIdentifier"));
-  return {
-    ...ctx,
-    depthIdentifier
-  };
-};
 //# sourceMappingURL=Arbitrary.js.map