effect 4.0.0-beta.39 → 4.0.0-beta.40

package/dist/Schema.js

@@ -22,7 +22,7 @@
  *
  * - Define a struct: {@link Struct}
  * - Define a union: {@link Union}, {@link TaggedUnion}, {@link Literals}
- * - Define an array: {@link Array}, {@link NonEmptyArray}
+ * - Define an array: {@link ArraySchema}, {@link NonEmptyArray}
  * - Define a record: {@link Record}
  * - Define a tuple: {@link Tuple}, {@link TupleWithRest}
  * - Validate unknown data synchronously: {@link decodeUnknownSync}
@@ -1518,6 +1518,14 @@ export function TupleWithRest(schema, rest) {
     rest
   });
 }
+/**
+ * @category Constructors
+ * @since 4.0.0
+ */
+const ArraySchema = /*#__PURE__*/Struct_.lambda(schema => make(new AST.Arrays(false, [], [schema.ast]), {
+  schema
+}));
+export {
 /**
  * Defines a `ReadonlyArray` schema for a given element schema.
  *
@@ -1536,9 +1544,7 @@ export function TupleWithRest(schema, rest) {
  * @category Constructors
  * @since 4.0.0
  */
-export const Array = /*#__PURE__*/Struct_.lambda(schema => make(new AST.Arrays(false, [], [schema.ast]), {
-  schema
-}));
+ArraySchema as Array };
 /**
  * Defines a non-empty `ReadonlyArray` schema — at least one element required.
  * Type is `readonly [T, ...T[]]`.
@@ -1575,7 +1581,7 @@ export const NonEmptyArray = /*#__PURE__*/Struct_.lambda(schema => make(new AST.
  * @since 4.0.0
  */
 export function ArrayEnsure(schema) {
-  return Union([schema, Array(schema)]).pipe(decodeTo(Array(toType(schema)), Transformation.transform({
+  return Union([schema, ArraySchema(schema)]).pipe(decodeTo(ArraySchema(toType(schema)), Transformation.transform({
     decode: Arr.ensure,
     encode: array => array.length === 1 ? array[0] : array
   })));
@@ -1590,7 +1596,7 @@ export function ArrayEnsure(schema) {
  * @since 4.0.0
  */
 export function UniqueArray(item) {
-  return Array(item).check(isUnique());
+  return ArraySchema(item).check(isUnique());
 }
 /**
  * Makes an array or tuple schema mutable, removing the `readonly` modifier.
@@ -4506,7 +4512,7 @@ function causeReasonToFormatter(error, defect) {
  */
 export function Cause(error, defect) {
   const schema = declareConstructor()([error, defect], ([error, defect]) => {
-    const failures = Array(CauseReason(error, defect));
+    const failures = ArraySchema(CauseReason(error, defect));
     return (input, ast, options) => {
       if (!Cause_.isCause(input)) {
         return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)));
@@ -4526,7 +4532,7 @@ export function Cause(error, defect) {
       importDeclaration: `import * as Cause from "effect/Cause"`
     },
     expected: "Cause",
-    toCodec: ([error, defect]) => link()(Array(CauseReason(error, defect)), Transformation.transform({
+    toCodec: ([error, defect]) => link()(ArraySchema(CauseReason(error, defect)), Transformation.transform({
       decode: Cause_.fromReasons,
       encode: ({
         reasons: failures
@@ -4728,7 +4734,7 @@ export function Exit(value, error, defect) {
  */
 export function ReadonlyMap(key, value) {
   const schema = declareConstructor()([key, value], ([key, value]) => {
-    const array = Array(Tuple([key, value]));
+    const array = ArraySchema(Tuple([key, value]));
     return (input, ast, options) => {
       if (input instanceof globalThis.Map) {
         return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
@@ -4747,7 +4753,7 @@ export function ReadonlyMap(key, value) {
       Type: `globalThis.ReadonlyMap<?, ?>`
     },
     expected: "ReadonlyMap",
-    toCodec: ([key, value]) => link()(Array(Tuple([key, value])), Transformation.transform({
+    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), Transformation.transform({
       decode: e => new globalThis.Map(e),
       encode: map => [...map.entries()]
     })),
@@ -4781,7 +4787,7 @@ export function ReadonlyMap(key, value) {
  */
 export function HashMap(key, value) {
   const schema = declareConstructor()([key, value], ([key, value]) => {
-    const entries = Array(Tuple([key, value]));
+    const entries = ArraySchema(Tuple([key, value]));
     return (input, ast, options) => {
       if (HashMap_.isHashMap(input)) {
         return Effect.mapBothEager(Parser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options), {
@@ -4801,7 +4807,7 @@ export function HashMap(key, value) {
       importDeclaration: `import * as HashMap from "effect/HashMap"`
     },
     expected: "HashMap",
-    toCodec: ([key, value]) => link()(Array(Tuple([key, value])), Transformation.transform({
+    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), Transformation.transform({
       decode: HashMap_.fromIterable,
       encode: HashMap_.toEntries
     })),
@@ -4832,7 +4838,7 @@ export function HashMap(key, value) {
  */
 export function ReadonlySet(value) {
   const schema = declareConstructor()([value], ([value]) => {
-    const array = Array(value);
+    const array = ArraySchema(value);
     return (input, ast, options) => {
       if (input instanceof globalThis.Set) {
         return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
@@ -4851,7 +4857,7 @@ export function ReadonlySet(value) {
       Type: `globalThis.ReadonlySet<?>`
     },
     expected: "ReadonlySet",
-    toCodec: ([value]) => link()(Array(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
       decode: e => new globalThis.Set(e),
       encode: set => [...set.values()]
     })),
@@ -4884,7 +4890,7 @@ export function ReadonlySet(value) {
  */
 export function HashSet(value) {
   const schema = declareConstructor()([value], ([value]) => {
-    const values = Array(value);
+    const values = ArraySchema(value);
     return (input, ast, options) => {
       if (HashSet_.isHashSet(input)) {
         return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
@@ -4903,7 +4909,7 @@ export function HashSet(value) {
       Type: `HashSet.HashSet<?>`
     },
     expected: "HashSet",
-    toCodec: ([value]) => link()(Array(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
       decode: HashSet_.fromIterable,
       encode: Arr.fromIterable
     })),
@@ -4936,7 +4942,7 @@ export function HashSet(value) {
  */
 export function Chunk(value) {
   const schema = declareConstructor()([value], ([value]) => {
-    const values = Array(value);
+    const values = ArraySchema(value);
     return (input, ast, options) => {
       if (Chunk_.isChunk(input)) {
         return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
@@ -4955,7 +4961,7 @@ export function Chunk(value) {
       Type: `Chunk.Chunk<?>`
     },
     expected: "Chunk",
-    toCodec: ([value]) => link()(Array(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
       decode: Chunk_.fromIterable,
       encode: Arr.fromIterable
     })),
@@ -5406,7 +5412,7 @@ export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
     Type: `globalThis.FormData`
   },
   expected: "FormData",
-  toCodecJson: () => link()(Array(Tuple([String, Union([Struct({
+  toCodecJson: () => link()(ArraySchema(Tuple([String, Union([Struct({
     _tag: tag("String"),
     value: String
   }), Struct({
@@ -5696,9 +5702,9 @@ export const PropertyKey = /*#__PURE__*/Union([Finite, Symbol, String]);
  * @since 4.0.0
  */
 export const StandardSchemaV1FailureResult = /*#__PURE__*/Struct({
-  issues: /*#__PURE__*/Array(/*#__PURE__*/Struct({
+  issues: /*#__PURE__*/ArraySchema(/*#__PURE__*/Struct({
     message: String,
-    path: /*#__PURE__*/optional(/*#__PURE__*/Array(/*#__PURE__*/Union([PropertyKey, /*#__PURE__*/Struct({
+    path: /*#__PURE__*/optional(/*#__PURE__*/ArraySchema(/*#__PURE__*/Union([PropertyKey, /*#__PURE__*/Struct({
       key: PropertyKey
     })])))
   }))
@@ -6830,7 +6836,7 @@ export function toDifferJsonPatch(schema) {
  */
 export function Tree(node) {
   const Tree$ref = suspend(() => Tree);
-  const Tree = Union([node, Array(Tree$ref), Record(String, Tree$ref)]);
+  const Tree = Union([node, ArraySchema(Tree$ref), Record(String, Tree$ref)]);
   return Tree;
 }
 /**