effect 4.0.0-beta.105 → 4.0.0-beta.106

package/dist/Schema.js

@@ -55,7 +55,6 @@ import * as SchemaIssue from "./SchemaIssue.js";
 import * as SchemaParser from "./SchemaParser.js";
 import * as SchemaTransformation from "./SchemaTransformation.js";
 import * as Struct_ from "./Struct.js";
-import * as FastCheck from "./testing/FastCheck.js";
 const TypeId = InternalSchema.TypeId;
 /**
  * Creates a schema for a **parametric** type (a generic container such as
@@ -1475,7 +1474,12 @@ export const requiredKey = /*#__PURE__*/Struct_.lambda(self => self.schema);
  * @category combinators
  * @since 3.10.0
  */
-export const optional = /*#__PURE__*/Struct_.lambda(self => optionalKey(UndefinedOr(self)));
+export const optional = /*#__PURE__*/Struct_.lambda(self => {
+  const schema = UndefinedOr(self);
+  return make(SchemaAST.optional(self.ast), {
+    schema
+  });
+});
 /**
  * Reverses `optional` and returns the inner schema.
  *
@@ -2665,7 +2669,7 @@ export function decodeTo(to, transformation) {
  * ```
  *
  * @category transforming
- * @since 3.10.0
+ * @since 4.0.0
  */
 export function decode(transformation) {
   return self => {
@@ -2701,7 +2705,7 @@ export function encodeTo(to, transformation) {
  * ```
  *
  * @category transforming
- * @since 3.10.0
+ * @since 4.0.0
  */
 export function encode(transformation) {
   return self => {
@@ -9212,35 +9216,41 @@ export const TaggedError = identifier => {
   };
 };
 /**
- * Derives a {@link LazyArbitrary} from a schema. The result is memoized so
- * repeated calls with the same schema are cheap.
+ * Returns an {@link Arbitrary} factory derived from a schema. The generated
+ * values satisfy the schema and use its decoded `Type`.
+ *
+ * **When to use**
+ *
+ * Use when you need a fast-check generator for values accepted by a schema.
  *
  * **Details**
  *
- * Prefer {@link toArbitrary} when you need the arbitrary directly, or when you
- * want derivation diagnostics via `{ report: true }`. Unsupported schema
- * nodes, impossible constraints, invalid candidates, and recursive schemas
- * without a finite terminal path fail immediately.
+ * Constraints refine base generators; candidates add weighted sources while
+ * filters still validate every value. Recursive schemas use terminal branches
+ * and fail when no finite terminal path exists. The result is memoized so
+ * repeated calls with the same schema are cheap.
+ *
+ * **Example** (Generating arbitrary values)
+ *
+ * ```ts import.meta.vitest
+ * import { Schema } from "effect"
+ * import * as FastCheck from "fast-check"
+ *
+ * const makePersonArbitrary = Schema.toArbitrary(
+ *   Schema.Struct({ name: Schema.String, age: Schema.Number })
+ * )
+ *
+ * const PersonArbitrary = makePersonArbitrary(FastCheck)
+ * FastCheck.sample(PersonArbitrary, 1)
+ * ```
  *
  * @category generators
  * @since 4.0.0
  */
-export function toArbitraryLazy(schema) {
+export function toArbitrary(schema) {
   const lawc = InternalArbitrary.memoized(schema.ast);
   return fc => lawc(fc, {});
 }
-export function toArbitrary(schema, options) {
-  if (options?.report === true) {
-    const lawc = InternalArbitrary.memoized(schema.ast);
-    const report = InternalArbitrary.makeReport();
-    InternalArbitrary.collectReport(schema.ast, report);
-    return {
-      value: lawc(FastCheck, {}),
-      report: InternalArbitrary.toReport(report)
-    };
-  }
-  return toArbitraryLazy(schema)(FastCheck);
-}
 // -----------------------------------------------------------------------------
 // Formatter
 // -----------------------------------------------------------------------------
@@ -9488,7 +9498,7 @@ export function toRepresentation(schema) {
  * @since 4.0.0
  */
 export function toJsonSchemaDocument(schema, options) {
-  const document = InternalToRepresentation.toRepresentation(toCodecJsonAST(schema.ast));
+  const document = InternalToRepresentation.toRepresentation(toCodecJsonAST(schema.ast), InternalToJsonSchemaDocument.toRepresentationOptions);
   return InternalToJsonSchemaDocument.toJsonSchemaDocument(document, options);
 }
 /**
@@ -9511,14 +9521,13 @@ export function toCodecJson(schema) {
     schema
   });
 }
-const toCodecJsonASTBase = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
-  const out = toCodecJsonBase(ast, toCodecJsonAST);
+/** @internal */
+export const toCodecJsonAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {
+  const out = toCodecJsonASTStep(ast, toCodecJsonAST);
   const context = ast.context;
   if (out === ast || context === undefined) return out;
   return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(context));
 });
-/** @internal */
-export const toCodecJsonAST = /*#__PURE__*/memoize(toCodecJsonASTBase);
 function withoutConstructorDefault(context) {
   return context.constructorDefault === undefined ? context : new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations);
 }
@@ -9562,7 +9571,7 @@ const toCodecJsonReorder = /*#__PURE__*/makeReorder(ast => {
       return 1;
   }
 });
-function toCodecJsonBase(ast, recur) {
+function toCodecJsonASTStep(ast, recur) {
   switch (ast._tag) {
     case "Declaration":
       {
@@ -9615,13 +9624,13 @@ function toCodecJsonBase(ast, recur) {
  * @since 4.0.0
  */
 export function toCodecIso(schema) {
-  return make(toCodecIsoTop(SchemaAST.toType(schema.ast)));
+  return make(toCodecIsoAST(SchemaAST.toType(schema.ast)));
 }
-const toCodecIsoTop = /*#__PURE__*/memoize(ast => {
-  const out = toCodecIsoBase(ast, toCodecIsoTop);
+const toCodecIsoAST = /*#__PURE__*/memoize(ast => {
+  const out = toCodecIsoASTStep(ast, toCodecIsoAST);
   return out !== ast && ast.context !== undefined ? SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context)) : out;
 });
-function toCodecIsoBase(ast, recur) {
+function toCodecIsoASTStep(ast, recur) {
   switch (ast._tag) {
     case "Declaration":
       {
@@ -9654,7 +9663,7 @@ function toCodecIsoBase(ast, recur) {
  * @since 4.0.0
  */
 export function toCodecStringTree(schema) {
-  return make(serializerStringTree(schema.ast), {
+  return make(toCodecStringTreeAST(schema.ast), {
     schema
   });
 }
@@ -9677,7 +9686,7 @@ export function toCodecStringTree(schema) {
  * @since 4.0.0
  */
 export function toCodecArrayFromSingle(schema) {
-  return make(toCodecArrayFromSingleTop(schema.ast));
+  return make(toCodecArrayFromSingleAST(schema.ast));
 }
 /**
  * Derives an XML encoder from a codec.
@@ -9801,7 +9810,7 @@ const toStringTreeReorder = /*#__PURE__*/makeReorder(ast => {
       return 1;
   }
 });
-function serializerTree(ast, recur, onMissingAnnotation) {
+function toCodecStringTreeASTStep(ast, recur, onMissingAnnotation) {
   switch (ast._tag) {
     case "Declaration":
       {
@@ -9854,13 +9863,10 @@ function serializerTree(ast, recur, onMissingAnnotation) {
 }
 const nullToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Literal("null"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(() => null), /*#__PURE__*/SchemaGetter.transform(() => "null")));
 const booleanToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Union([/*#__PURE__*/new SchemaAST.Literal("true"), /*#__PURE__*/new SchemaAST.Literal("false")], "anyOf"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(s => s === "true"), /*#__PURE__*/SchemaGetter.String()));
-const SERIALIZER_ENSURE_ARRAY = "~effect/Schema/SERIALIZER_ENSURE_ARRAY";
-const isSerializerArrayFromSingle = ast => SchemaAST.isUnion(ast) && ast.annotations?.[SERIALIZER_ENSURE_ARRAY] === true;
-const serializerStringTree = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
-  if (isSerializerArrayFromSingle(ast)) {
-    return ast;
-  }
-  const out = serializerTree(ast, serializerStringTree, ast => {
+const arrayFromSingleTransformation = /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(input => typeof input === "string" ? [input] : input), /*#__PURE__*/SchemaGetter.passthrough());
+const isCodecArrayFromSingleLink = link => link.transformation === arrayFromSingleTransformation;
+const toCodecStringTreeAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {
+  const out = toCodecStringTreeASTStep(ast, toCodecStringTreeAST, ast => {
     throw new globalThis.Error("Missing structural codec for StringTree", {
       cause: ast
     });
@@ -9869,24 +9875,22 @@ const serializerStringTree = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodin
     return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context));
   }
   return out;
+}, {
+  stopAt: isCodecArrayFromSingleLink
 });
 const toArrayFromSingleInputElement = ast => SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(SchemaAST.unknown) : SchemaAST.unknown;
-const arrayFromSingleTransformation = /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(input => typeof input === "string" ? [input] : input), /*#__PURE__*/SchemaGetter.passthrough());
-const toCodecArrayFromSingleTop = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
-  if (isSerializerArrayFromSingle(ast)) {
-    return ast;
-  }
-  const out = onSerializerArrayFromSingle(ast);
+const toCodecArrayFromSingleAST = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodingIdempotent(ast => {
+  const out = toCodecArrayFromSingleASTStep(ast);
   if (SchemaAST.isArrays(out)) {
-    const ensure = SchemaAST.decodeTo(new SchemaAST.Union([new SchemaAST.Arrays(out.isMutable, out.elements.map(toArrayFromSingleInputElement), out.rest.map(toArrayFromSingleInputElement)), SchemaAST.string], "anyOf", {
-      [SERIALIZER_ENSURE_ARRAY]: true
-    }), out, arrayFromSingleTransformation);
+    const ensure = SchemaAST.decodeTo(new SchemaAST.Union([new SchemaAST.Arrays(out.isMutable, out.elements.map(toArrayFromSingleInputElement), out.rest.map(toArrayFromSingleInputElement)), SchemaAST.string], "anyOf"), out, arrayFromSingleTransformation);
     return SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(ensure) : ensure;
   }
   return out;
+}, {
+  stopAt: isCodecArrayFromSingleLink
 });
-function onSerializerArrayFromSingle(ast) {
-  return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" || ast._tag === "Suspend" ? ast.recur(toCodecArrayFromSingleTop) : ast;
+function toCodecArrayFromSingleASTStep(ast) {
+  return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" || ast._tag === "Suspend" ? ast.recur(toCodecArrayFromSingleAST) : ast;
 }
 /**
  * Reviver for persisted `isGreaterThanDate` checks.