effect 4.0.0-beta.50 → 4.0.0-beta.52

package/src/BigDecimal.ts

@@ -142,6 +142,10 @@ export const makeNormalizedUnsafe = (value: bigint, scale: number): BigDecimal =
 
 const bigint0 = BigInt(0)
 const bigint1 = BigInt(1)
+const bigint_1 = BigInt(-1)
+const bigint2 = BigInt(2)
+const bigint5 = BigInt(5)
+const bigint_5 = BigInt(-5)
 const bigint10 = BigInt(10)
 const zero = makeNormalizedUnsafe(bigint0, 0)
 const one = makeNormalizedUnsafe(bigint1, 0)
@@ -2320,32 +2324,32 @@ export const round: {
       return (isPositive(self) ? ceil(self, scale) : floor(self, scale))
 
     case "half-ceil":
-      return floor(sum(self, make(5n, scale + 1)), scale)
+      return floor(sum(self, make(bigint5, scale + 1)), scale)
 
     case "half-floor":
-      return ceil(sum(self, make(-5n, scale + 1)), scale)
+      return ceil(sum(self, make(bigint_5, scale + 1)), scale)
 
     case "half-to-zero":
       return isNegative(self)
-        ? floor(sum(self, make(5n, scale + 1)), scale)
-        : ceil(sum(self, make(-5n, scale + 1)), scale)
+        ? floor(sum(self, make(bigint5, scale + 1)), scale)
+        : ceil(sum(self, make(bigint_5, scale + 1)), scale)
 
     case "half-from-zero":
       return isNegative(self)
-        ? ceil(sum(self, make(-5n, scale + 1)), scale)
-        : floor(sum(self, make(5n, scale + 1)), scale)
+        ? ceil(sum(self, make(bigint_5, scale + 1)), scale)
+        : floor(sum(self, make(bigint5, scale + 1)), scale)
   }
 
-  const halfCeil = floor(sum(self, make(5n, scale + 1)), scale)
-  const halfFloor = ceil(sum(self, make(-5n, scale + 1)), scale)
+  const halfCeil = floor(sum(self, make(bigint5, scale + 1)), scale)
+  const halfFloor = ceil(sum(self, make(bigint_5, scale + 1)), scale)
   const digit = digitAt(halfCeil, scale)
 
   switch (mode) {
     case "half-even":
-      return equals(halfCeil, halfFloor) ? halfCeil : (digit % 2n === 0n) ? halfCeil : halfFloor
+      return equals(halfCeil, halfFloor) ? halfCeil : (digit % bigint2 === bigint0) ? halfCeil : halfFloor
 
     case "half-odd":
-      return equals(halfCeil, halfFloor) ? halfCeil : (digit % 2n === 0n) ? halfFloor : halfCeil
+      return equals(halfCeil, halfFloor) ? halfCeil : (digit % bigint2 === bigint0) ? halfFloor : halfCeil
   }
 })
 
@@ -2421,7 +2425,7 @@ export const truncate: {
   }
 
   // BigInt division truncates towards zero
-  return make(self.value / (10n ** BigInt(self.scale - scale)), scale)
+  return make(self.value / (bigint10 ** BigInt(self.scale - scale)), scale)
 })
 
 /**
@@ -2485,7 +2489,7 @@ export const ceil: {
   const truncated = truncate(self, scale)
 
   if (isPositive(self) && isLessThan(truncated, self)) {
-    return sum(truncated, make(1n, scale))
+    return sum(truncated, make(bigint1, scale))
   }
 
   return truncated
@@ -2517,11 +2521,11 @@ export const digitAt: {
   (self: BigDecimal, scale: number): bigint
 } = dual(2, (self: BigDecimal, scale: number): bigint => {
   if (self.scale < scale) {
-    return 0n
+    return bigint0
   }
 
-  const scaled = self.value / (10n ** BigInt(self.scale - scale))
-  return scaled % 10n
+  const scaled = self.value / (bigint10 ** BigInt(self.scale - scale))
+  return scaled % bigint10
 })
 
 /**
@@ -2594,7 +2598,7 @@ export const floor: {
   const truncated = truncate(self, scale)
 
   if (isNegative(self) && isGreaterThan(truncated, self)) {
-    return sum(truncated, make(-1n, scale))
+    return sum(truncated, make(bigint_1, scale))
   }
 
   return truncated

package/src/BigInt.ts

@@ -1248,17 +1248,17 @@ export const remainder: {
  *
  * @since 4.0.0
  */
-export const ReducerSum: Reducer.Reducer<bigint> = Reducer.make((a, b) => a + b, 0n)
+export const ReducerSum: Reducer.Reducer<bigint> = Reducer.make((a, b) => a + b, bigint0)
 
 /**
  * A `Reducer` for combining `bigint`s using multiplication.
  *
  * @since 4.0.0
  */
-export const ReducerMultiply: Reducer.Reducer<bigint> = Reducer.make((a, b) => a * b, 1n, (collection) => {
-  let acc = 1n
+export const ReducerMultiply: Reducer.Reducer<bigint> = Reducer.make((a, b) => a * b, bigint1, (collection) => {
+  let acc = bigint1
   for (const n of collection) {
-    if (n === 0n) return 0n
+    if (n === bigint0) return bigint0
     acc *= n
   }
   return acc

package/src/Brand.ts

@@ -8,6 +8,7 @@
 import * as Arr from "./Array.ts"
 import * as Option from "./Option.ts"
 import * as Result from "./Result.ts"
+import type * as Schema from "./Schema.ts"
 import * as AST from "./SchemaAST.ts"
 import type * as Issue from "./SchemaIssue.ts"
 import type * as Types from "./Types.ts"
@@ -192,10 +193,7 @@ export function nominal<A extends Brand<any>>(): Constructor<A> {
  * @since 2.0.0
  */
 export function make<A extends Brand<any>>(
-  filter: (unbranded: Brand.Unbranded<A>) => undefined | boolean | string | Issue.Issue | {
-    readonly path: ReadonlyArray<PropertyKey>
-    readonly message: string
-  }
+  filter: (unbranded: Brand.Unbranded<A>) => Schema.FilterOutput
 ): Constructor<A> {
   return check(AST.makeFilter(filter))
 }

package/src/Data.ts

@@ -962,7 +962,7 @@ export const taggedEnum: {
         } else if (tag === "$match") {
           return taggedMatch
         }
-        return (props: any) => ({ _tag: tag, ...props })
+        return (props: any) => ({ ...props, _tag: tag })
       }
     }
   ) as any

package/src/Duration.ts

@@ -864,7 +864,7 @@ export const toHrTime = (self: Duration): [seconds: number, nanos: number] => {
       return [-Infinity, 0]
     case "Nanos": {
       const n = self.value.nanos
-      const sign = n < bigint0 ? -1n : 1n
+      const sign = n < bigint0 ? -BigInt(1) : BigInt(1)
       const a = n < bigint0 ? -n : n
       return [
         Number(sign * (a / bigint1e9)),

package/src/Schema.ts

@@ -103,7 +103,7 @@ import * as Equivalence from "./Equivalence.ts"
 import * as Exit_ from "./Exit.ts"
 import type { Formatter } from "./Formatter.ts"
 import { format, formatPropertyKey } from "./Formatter.ts"
-import { identity } from "./Function.ts"
+import { identity, memoize } from "./Function.ts"
 import * as HashMap_ from "./HashMap.ts"
 import * as HashSet_ from "./HashSet.ts"
 import * as core from "./internal/core.ts"
@@ -113,7 +113,6 @@ import * as InternalEquivalence from "./internal/schema/equivalence.ts"
 import * as InternalStandard from "./internal/schema/representation.ts"
 import * as InternalSchema from "./internal/schema/schema.ts"
 import { SchemaError } from "./internal/schema/schema.ts"
-import * as InternalToCodec from "./internal/schema/to-codec.ts"
 import * as JsonPatch from "./JsonPatch.ts"
 import * as JsonSchema from "./JsonSchema.ts"
 import { remainder } from "./Number.ts"
@@ -4930,9 +4929,8 @@ export function instanceOf<C extends abstract new(...args: any) => any, Iso = In
  * Used when building low-level AST transformations that bridge two schema types.
  *
  * @since 4.0.0
- * @experimental
  */
-export function link<T>() { // TODO: better name
+export function link<T>() {
   return <To extends Top>(
     encodeTo: To,
     transformation: {
@@ -4951,32 +4949,106 @@ export function link<T>() { // TODO: better name
 /**
  * Creates a custom filter check from a predicate function. The predicate
  * receives the input value, the schema's AST, and parse options, and returns
- * `true`/`undefined` on success or a failure description on error.
+ * a value of type {@link FilterOutput}.
+ *
+ * **Example** (Failure at a nested path)
  *
- * **Example** (Custom filter check)
  * ```ts
  * import { Schema } from "effect"
  *
- * // Check that a number is even
- * const isEven = Schema.makeFilter(
- *   (n: number) => n % 2 === 0 || "expected an even number"
+ * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
+ *   Schema.makeFilter((o) =>
+ *     o.password === o.confirmPassword
+ *       ? undefined
+ *       : { path: ["password"], issue: "password and confirmPassword must match" }
+ *   )
+ * )
+ *
+ * console.log(String(Schema.decodeUnknownExit(schema)({ password: "123456", confirmPassword: "1234567" })))
+ * // Failure(Cause([Fail(SchemaError: password and confirmPassword must match
+ * //   at ["password"])]))
+ * ```
+ *
+ * **Example** (Reporting multiple failures at once)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
+ *   Schema.makeFilter((o) => {
+ *     const issues: Array<Schema.FilterIssue> = []
+ *     if (o.a > 0) {
+ *       if (o.b <= 0) issues.push({ path: ["b"], issue: "b must be greater than 0" })
+ *       if (o.c <= 0) issues.push({ path: ["c"], issue: "c must be greater than 0" })
+ *     }
+ *     return issues
+ *   })
  * )
  *
- * const EvenNumber = Schema.Number.check(isEven)
+ * console.log(String(Schema.decodeUnknownExit(schema)({ a: 1, b: 0, c: 0 })))
+ * // Failure(Cause([Fail(SchemaError: b must be greater than 0
+ * //   at ["b"]
+ * // c must be greater than 0
+ * //   at ["c"])]))
  * ```
  *
  * @category Checks Constructors
  * @since 4.0.0
  */
 export const makeFilter: <T>(
-  filter: (input: T, ast: AST.AST, options: AST.ParseOptions) => undefined | boolean | string | Issue.Issue | {
-    readonly path: ReadonlyArray<PropertyKey>
-    readonly message: string
-  },
+  filter: (input: T, ast: AST.AST, options: AST.ParseOptions) => FilterOutput,
   annotations?: Annotations.Filter | undefined,
   abort?: boolean
 ) => AST.Filter<T> = AST.makeFilter
 
+/**
+ * A single failure reported by a filter predicate. Used as the element type
+ * of the array arm of {@link FilterOutput}, and also accepted on its own.
+ *
+ * - `string`: failure with that string as the message. Produces an
+ *   {@link Issue.InvalidValue} wrapping the input, with the string used as
+ *   the issue's `message` annotation.
+ * - {@link Issue.Issue}: a fully-formed issue, returned as-is.
+ * - `{ path, issue }`: failure attached to a nested path. `issue` is either
+ *   a `string` (wrapped in an {@link Issue.InvalidValue}) or a full
+ *   {@link Issue.Issue}; the result is wrapped in an {@link Issue.Pointer}
+ *   at the given `path`.
+ *
+ * @category model
+ * @since 4.0.0
+ */
+export type FilterIssue = string | Issue.Issue | {
+  readonly path: ReadonlyArray<PropertyKey>
+  readonly issue: string | Issue.Issue
+}
+
+/**
+ * The value a filter predicate (see {@link makeFilter}) may return.
+ *
+ * Each shape is normalized into an {@link Issue.Issue} (or `undefined` for
+ * success) before being attached to the parse result:
+ *
+ * - `undefined`: success. The input satisfies the filter.
+ * - `true`: success. Equivalent to `undefined`, useful when the predicate is
+ *   a plain boolean expression.
+ * - `false`: generic failure. Produces an {@link Issue.InvalidValue} wrapping
+ *   the input, with no custom message.
+ * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
+ *   shapes (`string`, {@link Issue.Issue}, or `{ path, issue }`).
+ * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
+ *   empty array is treated as success; a single-element array is equivalent
+ *   to returning that element directly; otherwise the entries are grouped
+ *   into an {@link Issue.Composite}.
+ *
+ * @category model
+ * @since 4.0.0
+ */
+export type FilterOutput =
+  | undefined
+  | boolean
+  | FilterIssue
+  | ReadonlyArray<FilterIssue>
+
 /**
  * Groups multiple checks into a single {@link AST.FilterGroup}, applying
  * optional shared annotations to the group as a whole.
@@ -8794,6 +8866,8 @@ export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
   readonly "Rebuild": DurationFromNanos
 }
 
+const bigint0 = globalThis.BigInt(0)
+
 /**
  * A transformation schema that decodes a non-negative `bigint` into a
  * `Duration`, treating the `bigint` value as the duration in nanoseconds.
@@ -8807,7 +8881,7 @@ export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
  * @category Duration
  * @since 4.0.0
  */
-export const DurationFromNanos: DurationFromNanos = BigInt.check(isGreaterThanOrEqualToBigInt(0n)).pipe(
+export const DurationFromNanos: DurationFromNanos = BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(
   decodeTo(Duration, Transformation.durationFromNanos)
 )
 
@@ -11420,7 +11494,66 @@ export function toJsonSchemaDocument(schema: Top, options?: ToJsonSchemaOptions)
  * @since 4.0.0
  */
 export function toCodecJson<T, E, RD, RE>(schema: Codec<T, E, RD, RE>): Codec<T, Json, RD, RE> {
-  return make(InternalToCodec.toCodecJson(schema.ast))
+  return make(toCodecJsonTop(schema.ast))
+}
+
+const toCodecJsonTop = AST.toCodec((ast) => {
+  const out = toCodecJsonBase(ast, toCodecJsonTop)
+  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out
+})
+
+function toCodecJsonBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AST {
+  switch (ast._tag) {
+    case "Declaration": {
+      const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec
+      if (Predicate.isFunction(getLink)) {
+        const tps = AST.isDeclaration(ast)
+          ? ast.typeParameters.map((tp) => InternalSchema.make(AST.toEncoded(tp)))
+          : []
+        const link = getLink(tps)
+        const to = recur(link.to)
+        return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)])
+      }
+      return AST.replaceEncoding(ast, [AST.unknownToNull])
+    }
+    case "Unknown":
+    case "ObjectKeyword":
+      return AST.replaceEncoding(ast, [AST.unknownToJson])
+    case "Undefined":
+    case "Void":
+    case "Literal":
+    case "Number":
+      return ast.toCodecJson()
+    case "UniqueSymbol":
+    case "Symbol":
+    case "BigInt":
+      return ast.toCodecStringTree()
+    case "Objects": {
+      if (ast.propertySignatures.some((ps) => typeof ps.name !== "string")) {
+        throw new globalThis.Error("Objects property names must be strings", { cause: ast })
+      }
+      return ast.recur(recur)
+    }
+    case "Union": {
+      const sortedTypes = InternalSchema.jsonReorder(ast.types)
+      if (sortedTypes !== ast.types) {
+        return new AST.Union(
+          sortedTypes,
+          ast.mode,
+          ast.annotations,
+          ast.checks,
+          ast.encoding,
+          ast.context
+        ).recur(recur)
+      }
+      return ast.recur(recur)
+    }
+    case "Arrays":
+    case "Suspend":
+      return ast.recur(recur)
+  }
+  // `Schema.Any` is used as an escape hatch
+  return ast
 }
 
 /**
@@ -11431,7 +11564,32 @@ export function toCodecJson<T, E, RD, RE>(schema: Codec<T, E, RD, RE>): Codec<T,
  * @since 4.0.0
  */
 export function toCodecIso<S extends Top>(schema: S): Codec<S["Type"], S["Iso"]> {
-  return make(InternalToCodec.toCodecIso(AST.toType(schema.ast)))
+  return make(toCodecIsoTop(AST.toType(schema.ast)))
+}
+
+const toCodecIsoTop = memoize((ast: AST.AST): AST.AST => {
+  const out = toCodecIsoBase(ast, toCodecIsoTop)
+  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out
+})
+
+function toCodecIsoBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AST {
+  switch (ast._tag) {
+    case "Declaration": {
+      const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec
+      if (Predicate.isFunction(getLink)) {
+        const link = getLink(ast.typeParameters.map((tp) => InternalSchema.make(tp)))
+        const to = recur(link.to)
+        return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)])
+      }
+      return ast
+    }
+    case "Arrays":
+    case "Objects":
+    case "Union":
+    case "Suspend":
+      return ast.recur(recur)
+  }
+  return ast
 }
 
 /**
@@ -11470,11 +11628,13 @@ export function toCodecStringTree<T, E, RD, RE>(
   schema: Codec<T, E, RD, RE>,
   options?: { readonly keepDeclarations?: boolean | undefined }
 ): Codec<T, unknown, RD, RE> {
-  if (options?.keepDeclarations === true) {
-    return make(toCodecEnsureArray(serializerStringTreeKeepDeclarations(schema.ast)))
-  } else {
-    return make(toCodecEnsureArray(serializerStringTree(schema.ast)))
-  }
+  return make(
+    toCodecEnsureArray(
+      options?.keepDeclarations === true
+        ? serializerStringTreeKeepDeclarations(schema.ast)
+        : serializerStringTree(schema.ast)
+    )
+  )
 }
 
 type XmlEncoderOptions = {
@@ -11607,7 +11767,7 @@ function getStringTreePriority(ast: AST.AST): number {
   }
 }
 
-const treeReorder = InternalToCodec.makeReorder(getStringTreePriority)
+const treeReorder = InternalSchema.makeReorder(getStringTreePriority)
 
 function serializerTree(
   ast: AST.AST,