merge ArrayFormatter / TreeFormatter into ParseResult

.changeset/cyan-sloths-lick.md

@@ -2,4 +2,6 @@
 "@effect/schema": minor
 ---
 
-Re-export modules from `effect`
+Re-export modules from `effect`.
+
+`ArrayFormatter` / `TreeFormatter` merged into `ParseResult` module.

.changeset/six-crabs-itch.md

@@ -4,21 +4,21 @@
 
 Merge Schema into Effect.
 
+### Modules
+
 Before
 
 ```ts
 import {
   Arbitrary,
-  ArrayFormatter,
   AST,
   Equivalence,
   FastCheck,
   JSONSchema,
   ParseResult,
   Pretty,
   Schema,
-  Serializable,
-  TreeFormatter
+  Serializable
 } from "@effect/schema"
 ```
 
@@ -27,15 +27,29 @@ After
 ```ts
 import {
   Arbitrary,
-  SchemaArrayFormatter, // changed
   SchemaAST, // changed
   SchemaEquivalence, // changed
   FastCheck,
   JSONSchema,
   ParseResult,
   Pretty,
   Schema,
-  Serializable,
-  SchemaTreeFormatter // changed
+  Serializable
 } from "effect"
 ```
+
+### Formatters
+
+`ArrayFormatter` / `TreeFormatter` merged into `ParseResult` module.
+
+Before
+
+```ts
+import { ArrayFormatter, TreeFormatter } from "@effect/schema"
+```
+
+After
+
+```ts
+import { ArrayFormatter, TreeFormatter } from "effect/ParseResult"
+```

packages/cli/src/internal/args.ts

@@ -8,11 +8,11 @@ import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import { dual, pipe } from "effect/Function"
 import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Redacted from "effect/Redacted"
 import * as Ref from "effect/Ref"
-import * as Schema from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
+import type * as Schema from "effect/Schema"
 import type * as Secret from "effect/Secret"
 import type * as Args from "../Args.js"
 import type * as CliConfig from "../CliConfig.js"
@@ -436,11 +436,11 @@ export const withSchema = dual<
     schema: Schema.Schema<B, I, FileSystem.FileSystem | Path.Path | Terminal.Terminal>
   ) => Args.Args<B>
 >(2, (self, schema) => {
-  const decode = Schema.decode(schema)
+  const decode = ParseResult.decode(schema)
   return mapEffect(self, (_) =>
     Effect.mapError(
       decode(_ as any),
-      (error) => InternalHelpDoc.p(TreeFormatter.formatErrorSync(error))
+      (issue) => InternalHelpDoc.p(ParseResult.TreeFormatter.formatIssueSync(issue))
     ))
 })
 

packages/cli/src/internal/options.ts

@@ -10,12 +10,12 @@ import { dual, pipe } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import * as Option from "effect/Option"
 import * as Order from "effect/Order"
+import * as ParseResult from "effect/ParseResult"
 import { pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import type * as Redacted from "effect/Redacted"
 import * as Ref from "effect/Ref"
-import * as Schema from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
+import type * as Schema from "effect/Schema"
 import type * as Secret from "effect/Secret"
 import type * as CliConfig from "../CliConfig.js"
 import type * as HelpDoc from "../HelpDoc.js"
@@ -671,11 +671,12 @@ export const withSchema = dual<
     schema: Schema.Schema<B, I, FileSystem.FileSystem | Path.Path | Terminal.Terminal>
   ) => Options.Options<B>
 >(2, (self, schema) => {
-  const decode = Schema.decode(schema)
+  const decode = ParseResult.decode(schema)
   return mapEffect(self, (_) =>
     Effect.mapError(
       decode(_ as any),
-      (error) => InternalValidationError.invalidValue(InternalHelpDoc.p(TreeFormatter.formatErrorSync(error)))
+      (issue) =>
+        InternalValidationError.invalidValue(InternalHelpDoc.p(ParseResult.TreeFormatter.formatIssueSync(issue)))
     ))
 })
 

packages/cluster-node/src/StorageFile.ts

@@ -11,18 +11,20 @@ import { pipe } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import * as Layer from "effect/Layer"
 import type * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
 import * as Queue from "effect/Queue"
 import * as Schema from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
 import * as Stream from "effect/Stream"
 import * as fs from "node:fs"
 
 /** @internal */
 export function jsonStringify<A, I>(value: A, schema: Schema.Schema<A, I>) {
   return pipe(
     value,
-    Schema.encode(schema),
-    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) })),
+    ParseResult.encode(schema),
+    Effect.mapError((issue) =>
+      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
+    ),
     Effect.map((_) => JSON.stringify(_))
   )
 }
@@ -31,8 +33,10 @@ export function jsonStringify<A, I>(value: A, schema: Schema.Schema<A, I>) {
 export function jsonParse<A, I>(value: string, schema: Schema.Schema<A, I>) {
   return pipe(
     Effect.sync(() => JSON.parse(value)),
-    Effect.flatMap(Schema.decode(schema)),
-    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) }))
+    Effect.flatMap(ParseResult.decode(schema)),
+    Effect.mapError((issue) =>
+      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
+    )
   )
 }
 

packages/cluster/src/internal/serialization.ts

@@ -2,8 +2,8 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Schema from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
+import * as ParseResult from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
 import type * as Serialization from "../Serialization.js"
 import * as SerializedMessage from "../SerializedMessage.js"
 import * as ShardingException from "../ShardingException.js"
@@ -23,8 +23,10 @@ export const serializationTag = Context.GenericTag<Serialization.Serialization>(
 function jsonStringify<A, I>(value: A, schema: Schema.Schema<A, I>) {
   return pipe(
     value,
-    Schema.encode(schema),
-    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) })),
+    ParseResult.encode(schema),
+    Effect.mapError((issue) =>
+      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
+    ),
     Effect.map((_) => JSON.stringify(_))
   )
 }
@@ -33,8 +35,10 @@ function jsonStringify<A, I>(value: A, schema: Schema.Schema<A, I>) {
 function jsonParse<A, I>(value: string, schema: Schema.Schema<A, I>) {
   return pipe(
     Effect.sync(() => JSON.parse(value)),
-    Effect.flatMap(Schema.decode(schema)),
-    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) }))
+    Effect.flatMap(ParseResult.decode(schema)),
+    Effect.mapError((issue) =>
+      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
+    )
   )
 }
 

packages/effect/benchmark/SchemaToString.ts

@@ -1,6 +1,5 @@
 import * as ParseResult from "effect/ParseResult"
 import * as S from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
 import { Bench } from "tinybench"
 
 /*
@@ -37,7 +36,7 @@ bench
     schema.ast.toJSON()
   })
   .add("TreeFormatter.formatIssueSync", function() {
-    TreeFormatter.formatIssueSync(result.left)
+    ParseResult.TreeFormatter.formatIssueSync(result.left)
   })
 
 await bench.run()

packages/effect/benchmark/SchemaTreeFormatter.ts

@@ -1,7 +1,6 @@
 import type * as Either from "effect/Either"
-import type * as ParseResult from "effect/ParseResult"
+import * as ParseResult from "effect/ParseResult"
 import * as S from "effect/Schema"
-import * as TreeFormatter from "effect/SchemaTreeFormatter"
 import { Bench } from "tinybench"
 
 /*
@@ -35,7 +34,7 @@ bench
     decodeUnknownEither(input)
   })
   .add("TreeFormatter.formatIssueSync(issue)", function() {
-    TreeFormatter.formatIssueSync(issue)
+    ParseResult.TreeFormatter.formatIssueSync(issue)
   })
 
 await bench.run()

packages/effect/src/Arbitrary.ts

@@ -2,13 +2,13 @@
  * @since 3.10.0
  */
 
-import * as Arr from "effect/Array"
-import * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
+import * as Arr from "./Array.js"
 import * as FastCheck from "./FastCheck.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as filters_ from "./internal/schema/filters.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 AST from "./SchemaAST.js"
 

packages/effect/src/JSONSchema.ts

@@ -2,11 +2,11 @@
  * @since 3.10.0
  */
 
-import * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
-import * as Record from "effect/Record"
 import * as errors_ from "./internal/schema/errors.js"
 import * as filters_ from "./internal/schema/filters.js"
+import * as Option from "./Option.js"
+import * as Predicate from "./Predicate.js"
+import * as Record from "./Record.js"
 import type * as Schema from "./Schema.js"
 import * as AST from "./SchemaAST.js"