Refactor ParseResult module

.changeset/gentle-readers-call.md

@@ -0,0 +1,8 @@
+---
+"@effect/schema": minor
+---
+
+Refactor `ParseResult` module:
+
+- rename `UnionMember` to `Member`
+- ast `ast` field to `Member`

src/ArrayFormatter.ts

@@ -25,7 +25,7 @@ const format = (self: ParseIssue, path: ReadonlyArray<PropertyKey> = []): Array<
       return ReadonlyArray.flatMap(self.errors, (e) => format(e, [...path, self.key]))
     case "Index":
       return ReadonlyArray.flatMap(self.errors, (e) => format(e, [...path, self.index]))
-    case "UnionMember":
+    case "Member":
       return ReadonlyArray.flatMap(self.errors, (e) => format(e, path))
     case "Missing":
       return [{ _tag, path, message: "Missing key or index" }]

src/ParseResult.ts

@@ -55,12 +55,14 @@ export const parseError = (
  * @since 1.0.0
  */
 export type ParseIssue =
-  | Type
+  // context
   | Index
   | Key
+  | Member
+  // primitives
+  | Type
   | Missing
   | Unexpected
-  | UnionMember
   | Forbidden
 
 /**
@@ -80,16 +82,6 @@ export interface Type {
   readonly message: Option.Option<string>
 }
 
-/**
- * The `Forbidden` variant of the `ParseIssue` type represents an error that occurs when an Effect is encounter but disallowed from execution.
- *
- * @category model
- * @since 1.0.0
- */
-export interface Forbidden {
-  readonly _tag: "Forbidden"
-}
-
 /**
  * @category constructors
  * @since 1.0.0
@@ -101,6 +93,16 @@ export const type = (expected: AST.AST, actual: unknown, message?: string): Type
   message: Option.fromNullable(message)
 })
 
+/**
+ * The `Forbidden` variant of the `ParseIssue` type represents an error that occurs when an Effect is encounter but disallowed from execution.
+ *
+ * @category model
+ * @since 1.0.0
+ */
+export interface Forbidden {
+  readonly _tag: "Forbidden"
+}
+
 /**
  * @category constructors
  * @since 1.0.0
@@ -199,18 +201,20 @@ export const unexpected = (
  * @category model
  * @since 1.0.0
  */
-export interface UnionMember {
-  readonly _tag: "UnionMember"
+export interface Member {
+  readonly _tag: "Member"
+  readonly ast: AST.AST
   readonly errors: ReadonlyArray.NonEmptyReadonlyArray<ParseIssue>
 }
 
 /**
  * @category constructors
  * @since 1.0.0
  */
-export const unionMember = (
+export const member = (
+  ast: AST.AST,
   errors: ReadonlyArray.NonEmptyReadonlyArray<ParseIssue>
-): UnionMember => ({ _tag: "UnionMember", errors })
+): Member => ({ _tag: "Member", ast, errors })
 
 /**
  * @category constructors

src/Parser.ts

@@ -843,7 +843,8 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser<any, any> => {
         }
 
         for (let i = 0; i < candidates.length; i++) {
-          const pr = map.get(candidates[i])!(input, options)
+          const candidate = candidates[i]
+          const pr = map.get(candidate)!(input, options)
           // the members of a union are ordered based on which one should be decoded first,
           // therefore if one member has added a task, all subsequent members must
           // also add a task to the queue even if they are synchronous
@@ -852,7 +853,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser<any, any> => {
             if (Either.isRight(eu)) {
               return ParseResult.succeed(eu.right)
             } else {
-              es.push([stepKey++, ParseResult.unionMember(eu.left.errors)])
+              es.push([stepKey++, ParseResult.member(candidate, eu.left.errors)])
             }
           } else {
             const nk = stepKey++
@@ -869,7 +870,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser<any, any> => {
                       if (Either.isRight(t)) {
                         state.finalResult = ParseResult.succeed(t.right)
                       } else {
-                        state.es.push([nk, ParseResult.unionMember(t.left.errors)])
+                        state.es.push([nk, ParseResult.member(candidate, t.left.errors)])
                       }
                       return Effect.unit
                     })

src/TreeFormatter.ts

@@ -115,11 +115,11 @@ export const formatExpected = (ast: AST.AST): string => {
     case "Tuple":
       return Option.getOrElse(getExpected(ast), () => "<anonymous tuple or array schema>")
     case "TypeLiteral":
-      return Option.getOrElse(getExpected(ast), () => "<anonymous type literal schema>")
+      return Option.getOrElse(getExpected(ast), () => "<anonymous type literal or record schema>")
     case "Enums":
       return Option.getOrElse(
         getExpected(ast),
-        () => ast.enums.map((_, value) => JSON.stringify(value)).join(" | ")
+        () => `<anonymous enum ${ast.enums.map((_, value) => JSON.stringify(value)).join(" | ")}>`
       )
     case "Suspend":
       return Option.getOrElse(getExpected(ast), () => "<anonymous suspended schema>")
@@ -130,13 +130,13 @@ export const formatExpected = (ast: AST.AST): string => {
     case "Transform":
       return Option.getOrElse(
         getExpected(ast),
-        () => `${formatExpected(ast.from)} <-> ${formatExpected(ast.to)}`
+        () => `<anonymous transformation ${formatExpected(ast.from)} <-> ${formatExpected(ast.to)}>`
       )
   }
 }
 
 const isCollapsible = (es: Forest<string>, errors: NonEmptyReadonlyArray<ParseIssue>): boolean =>
-  es.length === 1 && es[0].forest.length !== 0 && errors[0]._tag !== "UnionMember"
+  es.length === 1 && es[0].forest.length !== 0 && errors[0]._tag !== "Member"
 
 /** @internal */
 export const getMessage = (e: Type) =>
@@ -174,7 +174,10 @@ const go = (e: ParseIssue): Tree<string> => {
     }
     case "Missing":
       return make("is missing")
-    case "UnionMember":
-      return make("union member", e.errors.map(go))
+    case "Member":
+      return make(
+        `union member: ${formatExpected(e.ast)}`,
+        e.errors.map(go)
+      )
   }
 }

test/ArrayFormatter.test.ts

@@ -103,7 +103,7 @@ describe("ArrayFormatter", () => {
     }])
   })
 
-  it("UnionMember", () => {
+  it("Member", () => {
     const schema = S.union(S.string, S.number)
     expectIssues(schema, null, [{
       _tag: "Type",

test/BigDecimal/BigDecimal.test.ts

@@ -25,7 +25,7 @@ describe("BigDecimal/BigDecimal", () => {
     await Util.expectParseFailure(
       schema,
       "abc",
-      `Expected string <-> BigDecimal, actual "abc"`
+      `Expected <anonymous transformation string <-> BigDecimal>, actual "abc"`
     )
   })
 

test/Cause/cause.test.ts

@@ -68,7 +68,7 @@ describe("Cause/cause", () => {
     await Util.expectParseFailure(
       schema,
       null,
-      `Expected <anonymous type literal schema>, actual null`
+      `Expected <anonymous type literal or record schema>, actual null`
     )
     await Util.expectParseFailure(
       schema,

test/Cause/causeFromSelf.test.ts

@@ -19,12 +19,12 @@ describe("Cause/causeFromSelf", () => {
     await Util.expectParseFailure(
       schema,
       Cause.fail("a"),
-      `union member: /error Expected string <-> number, actual "a"`
+      `union member: /error Expected <anonymous transformation string <-> number>, actual "a"`
     )
     await Util.expectParseFailure(
       schema,
       Cause.parallel(Cause.die("error"), Cause.fail("a")),
-      `union member: /right union member: /error Expected string <-> number, actual "a"`
+      `union member: /right union member: /error Expected <anonymous transformation string <-> number>, actual "a"`
     )
   })
 

test/Chunk/chunkFromSelf.test.ts

@@ -27,7 +27,7 @@ describe("Chunk/chunkFromSelf", () => {
     await Util.expectParseFailure(
       schema,
       C.fromIterable(["1", "a", "3"]),
-      `/1 Expected string <-> number, actual "a"`
+      `/1 Expected <anonymous transformation string <-> number>, actual "a"`
     )
   })
 

test/Parser.test.ts

@@ -23,7 +23,7 @@ describe("Parser", () => {
     expect(P.parseSync(schema)("1")).toEqual(1)
     expect(() => P.parseSync(schema)("a")).toThrow(
       new Error(`error(s) found
-└─ Expected string <-> number, actual "a"`)
+└─ Expected <anonymous transformation string <-> number>, actual "a"`)
     )
   })
 
@@ -36,7 +36,9 @@ describe("Parser", () => {
   it("parseEither", () => {
     const schema = S.NumberFromString
     expect(P.parseEither(schema)("1")).toEqual(E.right(1))
-    expect(P.parseEither(schema)("a")).toEqual(E.left(PR.parseError([PR.type(schema.ast, "a")])))
+    expect(P.parseEither(schema)("a")).toEqual(
+      E.left(PR.parseError([PR.type(schema.ast, "a")]))
+    )
   })
 
   it("parsePromise", async () => {
@@ -60,7 +62,7 @@ describe("Parser", () => {
     expect(P.decodeSync(schema)("1")).toEqual(1)
     expect(() => P.decodeSync(schema)("a")).toThrow(
       new Error(`error(s) found
-└─ Expected string <-> number, actual "a"`)
+└─ Expected <anonymous transformation string <-> number>, actual "a"`)
     )
   })
 
@@ -73,7 +75,9 @@ describe("Parser", () => {
   it("decodeEither", () => {
     const schema = S.NumberFromString
     expect(P.decodeEither(schema)("1")).toEqual(E.right(1))
-    expect(P.decodeEither(schema)("a")).toEqual(E.left(PR.parseError([PR.type(schema.ast, "a")])))
+    expect(P.decodeEither(schema)("a")).toEqual(
+      E.left(PR.parseError([PR.type(schema.ast, "a")]))
+    )
   })
 
   it("decodePromise", async () => {

test/ReadonlyMap/readonlyMapFromSelf.test.ts

@@ -26,7 +26,7 @@ describe("ReadonlyMap/readonlyMapFromSelf", () => {
     await Util.expectParseFailure(
       schema,
       new Map([["1", "a"], ["a", "b"]]),
-      `/1 /0 Expected string <-> number, actual "a"`
+      `/1 /0 Expected <anonymous transformation string <-> number>, actual "a"`
     )
   })
 

test/ReadonlySet/readonlySetFromSelf.test.ts

@@ -22,7 +22,7 @@ describe("ReadonlySet/readonlySetFromSelf", () => {
     await Util.expectParseFailure(
       schema,
       new Set(["1", "a", "3"]),
-      `/1 Expected string <-> number, actual "a"`
+      `/1 Expected <anonymous transformation string <-> number>, actual "a"`
     )
   })
 

test/Schema/PropertySignatureTransformations.test.ts

@@ -30,7 +30,7 @@ describe("Schema/PropertySignatureTransformations", () => {
     await Util.expectParseFailure(
       transform,
       { a: "a" },
-      `/a Expected string <-> number, actual "a"`
+      `/a Expected <anonymous transformation string <-> number>, actual "a"`
     )
 
     await Util.expectEncodeSuccess(transform, { a: 1 }, { a: "1" })
@@ -61,7 +61,7 @@ describe("Schema/PropertySignatureTransformations", () => {
     await Util.expectParseFailure(
       transform,
       { a: "a" },
-      `/a Expected string <-> number, actual "a"`
+      `/a Expected <anonymous transformation string <-> number>, actual "a"`
     )
 
     await Util.expectEncodeSuccess(transform, { a: 1 }, { a: "1" })
@@ -93,7 +93,7 @@ describe("Schema/PropertySignatureTransformations", () => {
     await Util.expectParseFailure(
       transform,
       { a: "a" },
-      `/a Expected string <-> number, actual "a"`
+      `/a Expected <anonymous transformation string <-> number>, actual "a"`
     )
 
     await Util.expectEncodeSuccess(transform, { a: O.some(1) }, { a: "1" })

test/Schema/compose.test.ts

@@ -13,13 +13,21 @@ describe("Schema/compose", async () => {
   it("force decoding: (A U B) compose (B -> C)", async () => {
     const schema1 = S.compose(S.union(S.null, S.string), S.NumberFromString)
     await Util.expectParseSuccess(schema1, "1", 1)
-    await Util.expectParseFailure(schema1, "a", `Expected string <-> number, actual "a"`)
+    await Util.expectParseFailure(
+      schema1,
+      "a",
+      `Expected <anonymous transformation string <-> number>, actual "a"`
+    )
     await Util.expectParseFailure(schema1, null, "Expected string, actual null")
     const schema2 = S.union(S.null, S.string).pipe(
       S.compose(S.NumberFromString)
     )
     await Util.expectParseSuccess(schema2, "1", 1)
-    await Util.expectParseFailure(schema2, "a", `Expected string <-> number, actual "a"`)
+    await Util.expectParseFailure(
+      schema2,
+      "a",
+      `Expected <anonymous transformation string <-> number>, actual "a"`
+    )
     await Util.expectParseFailure(schema2, null, "Expected string, actual null")
   })
 

test/Schema/enums.test.ts

@@ -19,7 +19,7 @@ describe("Schema/enums", () => {
       await Util.expectParseFailure(
         schema,
         3,
-        `Expected 0 | 1, actual 3`
+        `Expected <anonymous enum 0 | 1>, actual 3`
       )
     })
 
@@ -47,7 +47,7 @@ describe("Schema/enums", () => {
       await Util.expectParseFailure(
         schema,
         "Cantaloupe",
-        `Expected 0 | 1 | 2, actual "Cantaloupe"`
+        `Expected <anonymous enum 0 | 1 | 2>, actual "Cantaloupe"`
       )
     })
 
@@ -74,7 +74,7 @@ describe("Schema/enums", () => {
       await Util.expectParseFailure(
         schema,
         "Cantaloupe",
-        `Expected 0 | 1 | 2, actual "Cantaloupe"`
+        `Expected <anonymous enum 0 | 1 | 2>, actual "Cantaloupe"`
       )
     })
 

test/Schema/filter.test.ts

@@ -42,7 +42,11 @@ describe("Schema/filter", () => {
           : Option.some(
             ParseResult.parseError([
               ParseResult.key("b", [
-                ParseResult.type(S.literal(o.a).ast, o.b, `should be equal to a's value ("${o.a}")`)
+                ParseResult.type(
+                  S.literal(o.a).ast,
+                  o.b,
+                  `should be equal to a's value ("${o.a}")`
+                )
               ])
             ])
           )

test/Schema/literal.test.ts

@@ -36,9 +36,9 @@ describe("Schema/literal", () => {
         schema,
         null,
         `error(s) found
-├─ union member
+├─ union member: 1
 │  └─ Expected 1, actual null
-└─ union member
+└─ union member: "a"
    └─ Expected "a", actual null`
       )
     })

test/Schema/omit.test.ts

@@ -13,7 +13,7 @@ describe("Schema/omit", () => {
     await Util.expectParseFailure(
       schema,
       null,
-      "Expected <anonymous type literal schema>, actual null"
+      "Expected <anonymous type literal or record schema>, actual null"
     )
     await Util.expectParseFailure(schema, { [a]: "a" }, `/b is missing`)
     await Util.expectParseFailure(
@@ -38,7 +38,7 @@ describe("Schema/omit", () => {
     await Util.expectParseFailure(
       schema,
       null,
-      "Expected <anonymous type literal schema>, actual null"
+      "Expected <anonymous type literal or record schema>, actual null"
     )
     await Util.expectParseFailure(schema, { a: "a" }, `/b is missing`)
   })