effect 3.12.8 → 3.12.10

package/src/ParseResult.ts

@@ -307,6 +307,8 @@ export const fromOption: {
   <A>(self: Option.Option<A>, onNone: () => ParseIssue): Either.Either<A, ParseIssue>
 } = Either.fromOption
 
+const isEither: <A, E, R>(self: Effect.Effect<A, E, R>) => self is Either.Either<A, E> = Either.isEither as any
+
 /**
  * @category optimisation
  * @since 3.10.0
@@ -331,14 +333,9 @@ export const flatMap: {
   self: Effect.Effect<A, E, R>,
   f: (a: A) => Effect.Effect<B, E1, R1>
 ): Effect.Effect<B, E | E1, R | R1> => {
-  const s: any = self
-  if (s["_tag"] === "Left") {
-    return s
-  }
-  if (s["_tag"] === "Right") {
-    return f(s.right)
-  }
-  return Effect.flatMap(self, f)
+  return isEither(self) ?
+    Either.match(self, { onLeft: Either.left, onRight: f }) :
+    Effect.flatMap(self, f)
 })
 
 /**
@@ -357,14 +354,9 @@ export const map: {
    */
   <A, E, R, B>(self: Effect.Effect<A, E, R>, f: (a: A) => B): Effect.Effect<B, E, R>
 } = dual(2, <A, E, R, B>(self: Effect.Effect<A, E, R>, f: (a: A) => B): Effect.Effect<B, E, R> => {
-  const s: any = self
-  if (s["_tag"] === "Left") {
-    return s
-  }
-  if (s["_tag"] === "Right") {
-    return Either.right(f(s.right))
-  }
-  return Effect.map(self, f)
+  return isEither(self) ?
+    Either.map(self, f) :
+    Effect.map(self, f)
 })
 
 /**
@@ -383,16 +375,12 @@ export const mapError: {
    */
   <A, E, R, E2>(self: Effect.Effect<A, E, R>, f: (e: E) => E2): Effect.Effect<A, E2, R>
 } = dual(2, <A, E, R, E2>(self: Effect.Effect<A, E, R>, f: (e: E) => E2): Effect.Effect<A, E2, R> => {
-  const s: any = self
-  if (s["_tag"] === "Left") {
-    return Either.left(f(s.left))
-  }
-  if (s["_tag"] === "Right") {
-    return s
-  }
-  return Effect.mapError(self, f)
+  return isEither(self) ?
+    Either.mapLeft(self, f) :
+    Effect.mapError(self, f)
 })
 
+// TODO(4.0): remove
 /**
  * @category optimisation
  * @since 3.10.0
@@ -400,9 +388,8 @@ export const mapError: {
 export const eitherOrUndefined = <A, E, R>(
   self: Effect.Effect<A, E, R>
 ): Either.Either<A, E> | undefined => {
-  const s: any = self
-  if (s["_tag"] === "Left" || s["_tag"] === "Right") {
-    return s
+  if (isEither(self)) {
+    return self
   }
 }
 
@@ -430,14 +417,9 @@ export const mapBoth: {
   self: Effect.Effect<A, E, R>,
   options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
 ): Effect.Effect<A2, E2, R> => {
-  const s: any = self
-  if (s["_tag"] === "Left") {
-    return Either.left(options.onFailure(s.left))
-  }
-  if (s["_tag"] === "Right") {
-    return Either.right(options.onSuccess(s.right))
-  }
-  return Effect.mapBoth(self, options)
+  return isEither(self) ?
+    Either.mapBoth(self, { onLeft: options.onFailure, onRight: options.onSuccess }) :
+    Effect.mapBoth(self, options)
 })
 
 /**
@@ -464,14 +446,9 @@ export const orElse: {
   self: Effect.Effect<A, E, R>,
   f: (e: E) => Effect.Effect<A2, E2, R2>
 ): Effect.Effect<A2 | A, E2, R2 | R> => {
-  const s: any = self
-  if (s["_tag"] === "Left") {
-    return f(s.left)
-  }
-  if (s["_tag"] === "Right") {
-    return s
-  }
-  return Effect.catchAll(self, f)
+  return isEither(self) ?
+    Either.match(self, { onLeft: f, onRight: Either.right }) :
+    Effect.catchAll(self, f)
 })
 
 /**
@@ -1018,11 +995,10 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           } else {
             const parser = elements[i]
             const te = parser(input[i], options)
-            const eu = eitherOrUndefined(te)
-            if (eu) {
-              if (Either.isLeft(eu)) {
+            if (isEither(te)) {
+              if (Either.isLeft(te)) {
                 // the input element is present but is not valid
-                const e = new Pointer(i, input, eu.left)
+                const e = new Pointer(i, input, te.left)
                 if (allErrors) {
                   es.push([stepKey++, e])
                   continue
@@ -1030,7 +1006,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                   return Either.left(new Composite(ast, input, e, sortByIndex(output)))
                 }
               }
-              output.push([stepKey++, eu.right])
+              output.push([stepKey++, te.right])
             } else {
               const nk = stepKey++
               const index = i
@@ -1063,10 +1039,9 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           const [head, ...tail] = rest
           for (; i < len - tail.length; i++) {
             const te = head(input[i], options)
-            const eu = eitherOrUndefined(te)
-            if (eu) {
-              if (Either.isLeft(eu)) {
-                const e = new Pointer(i, input, eu.left)
+            if (isEither(te)) {
+              if (Either.isLeft(te)) {
+                const e = new Pointer(i, input, te.left)
                 if (allErrors) {
                   es.push([stepKey++, e])
                   continue
@@ -1074,7 +1049,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                   return Either.left(new Composite(ast, input, e, sortByIndex(output)))
                 }
               } else {
-                output.push([stepKey++, eu.right])
+                output.push([stepKey++, te.right])
               }
             } else {
               const nk = stepKey++
@@ -1110,11 +1085,10 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
               continue
             } else {
               const te = tail[j](input[i], options)
-              const eu = eitherOrUndefined(te)
-              if (eu) {
-                if (Either.isLeft(eu)) {
+              if (isEither(te)) {
+                if (Either.isLeft(te)) {
                   // the input element is present but is not valid
-                  const e = new Pointer(i, input, eu.left)
+                  const e = new Pointer(i, input, te.left)
                   if (allErrors) {
                     es.push([stepKey++, e])
                     continue
@@ -1122,7 +1096,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                     return Either.left(new Composite(ast, input, e, sortByIndex(output)))
                   }
                 }
-                output.push([stepKey++, eu.right])
+                output.push([stepKey++, te.right])
               } else {
                 const nk = stepKey++
                 const index = i
@@ -1221,8 +1195,8 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         if (onExcessPropertyError || onExcessPropertyPreserve) {
           inputKeys = util_.ownKeys(input)
           for (const key of inputKeys) {
-            const eu = eitherOrUndefined(expected(key, options))!
-            if (Either.isLeft(eu)) {
+            const te = expected(key, options)
+            if (isEither(te) && Either.isLeft(te)) {
               // key is unexpected
               if (onExcessPropertyError) {
                 const e = new Pointer(
@@ -1275,10 +1249,9 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           }
           const parser = propertySignatures[i][0]
           const te = parser(input[name], options)
-          const eu = eitherOrUndefined(te)
-          if (eu) {
-            if (Either.isLeft(eu)) {
-              const e = new Pointer(name, input, hasKey ? eu.left : new Missing(ps))
+          if (isEither(te)) {
+            if (Either.isLeft(te)) {
+              const e = new Pointer(name, input, hasKey ? te.left : new Missing(ps))
               if (allErrors) {
                 es.push([stepKey++, e])
                 continue
@@ -1286,7 +1259,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                 return Either.left(new Composite(ast, input, e, output))
               }
             }
-            output[name] = eu.right
+            output[name] = te.right
           } else {
             const nk = stepKey++
             const index = name
@@ -1324,16 +1297,15 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
             // ---------------------------------------------
             // handle keys
             // ---------------------------------------------
-            const keu = eitherOrUndefined(parameter(key, options))
-            if (keu && Either.isRight(keu)) {
+            const keu = parameter(key, options)
+            if (isEither(keu) && Either.isRight(keu)) {
               // ---------------------------------------------
               // handle values
               // ---------------------------------------------
               const vpr = type(input[key], options)
-              const veu = eitherOrUndefined(vpr)
-              if (veu) {
-                if (Either.isLeft(veu)) {
-                  const e = new Pointer(key, input, veu.left)
+              if (isEither(vpr)) {
+                if (Either.isLeft(vpr)) {
+                  const e = new Pointer(key, input, vpr.left)
                   if (allErrors) {
                     es.push([stepKey++, e])
                     continue
@@ -1342,7 +1314,7 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                   }
                 } else {
                   if (!Object.prototype.hasOwnProperty.call(expectedKeysMap, key)) {
-                    output[key] = veu.right
+                    output[key] = vpr.right
                   }
                 }
               } else {
@@ -1494,12 +1466,11 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
           // 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
-          const eu = !queue || queue.length === 0 ? eitherOrUndefined(pr) : undefined
-          if (eu) {
-            if (Either.isRight(eu)) {
-              return eu
+          if (isEither(pr) && (!queue || queue.length === 0)) {
+            if (Either.isRight(pr)) {
+              return pr
             } else {
-              es.push([stepKey++, eu.left])
+              es.push([stepKey++, pr.left])
             }
           } else {
             const nk = stepKey++
@@ -1694,11 +1665,9 @@ const handleForbidden = <A, R>(
     return effect
   }
 
-  // Convert the effect to an Either, if possible
-  const eu = eitherOrUndefined(effect)
   // If the effect is already an Either, return it directly
-  if (eu) {
-    return eu
+  if (isEither(effect)) {
+    return effect
   }
 
   // Otherwise, attempt to execute the effect synchronously
@@ -1823,8 +1792,11 @@ export interface ParseResultFormatter<A> {
  * @since 3.10.0
  */
 export const TreeFormatter: ParseResultFormatter<string> = {
-  formatIssue: (issue) => Effect.map(formatTree(issue), drawTree),
-  formatIssueSync: (issue) => Effect.runSync(TreeFormatter.formatIssue(issue)),
+  formatIssue: (issue) => map(formatTree(issue), drawTree),
+  formatIssueSync: (issue) => {
+    const e = TreeFormatter.formatIssue(issue)
+    return isEither(e) ? Either.getOrThrow(e) : Effect.runSync(e)
+  },
   formatError: (error) => TreeFormatter.formatIssue(error.issue),
   formatErrorSync: (error) => TreeFormatter.formatIssueSync(error.issue)
 }
@@ -1872,20 +1844,27 @@ interface CurrentMessage {
   readonly override: boolean
 }
 
-const getCurrentMessage = (
-  issue: ParseIssue
-): Effect.Effect<CurrentMessage, Cause.NoSuchElementException> =>
+// TODO: replace with Either.void when 3.13 lands
+const Either_void = Either.right(undefined)
+
+const getCurrentMessage = (issue: ParseIssue): Effect.Effect<CurrentMessage | undefined> =>
   getAnnotated(issue).pipe(
     Option.flatMap(AST.getMessageAnnotation),
-    Effect.flatMap((annotation) => {
-      const out = annotation(issue)
-      return Predicate.isString(out)
-        ? Effect.succeed({ message: out, override: false })
-        : Effect.isEffect(out)
-        ? Effect.map(out, (message) => ({ message, override: false }))
-        : Predicate.isString(out.message)
-        ? Effect.succeed({ message: out.message, override: out.override })
-        : Effect.map(out.message, (message) => ({ message, override: out.override }))
+    Option.match({
+      onNone: () => Either_void,
+      onSome: (messageAnnotation) => {
+        const union = messageAnnotation(issue)
+        if (Predicate.isString(union)) {
+          return Either.right({ message: union, override: false })
+        }
+        if (Effect.isEffect(union)) {
+          return Effect.map(union, (message) => ({ message, override: false }))
+        }
+        if (Predicate.isString(union.message)) {
+          return Either.right({ message: union.message, override: union.override })
+        }
+        return Effect.map(union.message, (message) => ({ message, override: union.override }))
+      }
     })
   )
 
@@ -1904,28 +1883,28 @@ export const isComposite = createParseIssueGuard("Composite")
 const isRefinement = createParseIssueGuard("Refinement")
 const isTransformation = createParseIssueGuard("Transformation")
 
-const getMessage: (
-  issue: ParseIssue
-) => Effect.Effect<string, Cause.NoSuchElementException> = (issue: ParseIssue) =>
-  getCurrentMessage(issue).pipe(
-    Effect.flatMap((currentMessage) => {
+const getMessage = (issue: ParseIssue): Effect.Effect<string | undefined> =>
+  flatMap(getCurrentMessage(issue), (currentMessage) => {
+    if (currentMessage !== undefined) {
       const useInnerMessage = !currentMessage.override && (
         isComposite(issue) ||
         (isRefinement(issue) && issue.kind === "From") ||
         (isTransformation(issue) && issue.kind !== "Transformation")
       )
       return useInnerMessage
-        ? isTransformation(issue) || isRefinement(issue) ? getMessage(issue.issue) : Option.none()
-        : Effect.succeed(currentMessage.message)
-    })
-  )
+        ? isTransformation(issue) || isRefinement(issue) ? getMessage(issue.issue) : Either_void
+        : Either.right(currentMessage.message)
+    }
+    return Either_void
+  })
 
-const getParseIssueTitleAnnotation = (issue: ParseIssue): Option.Option<string> =>
+const getParseIssueTitleAnnotation = (issue: ParseIssue): string | undefined =>
   getAnnotated(issue).pipe(
     Option.flatMap(AST.getParseIssueTitleAnnotation),
     Option.filterMap(
       (annotation) => Option.fromNullable(annotation(issue))
-    )
+    ),
+    Option.getOrUndefined
   )
 
 /** @internal */
@@ -1938,82 +1917,79 @@ export function getRefinementExpected(ast: AST.Refinement): string {
   )
 }
 
-function getDefaultTypeMessage(e: Type): string {
-  if (e.message !== undefined) {
-    return e.message
+function getDefaultTypeMessage(issue: Type): string {
+  if (issue.message !== undefined) {
+    return issue.message
   }
-  const expected = AST.isRefinement(e.ast) ? getRefinementExpected(e.ast) : String(e.ast)
-  return `Expected ${expected}, actual ${util_.formatUnknown(e.actual)}`
+  const expected = AST.isRefinement(issue.ast) ? getRefinementExpected(issue.ast) : String(issue.ast)
+  return `Expected ${expected}, actual ${util_.formatUnknown(issue.actual)}`
 }
 
-const formatTypeMessage = (e: Type): Effect.Effect<string> =>
-  getMessage(e).pipe(
-    Effect.orElse(() => getParseIssueTitleAnnotation(e)),
-    Effect.catchAll(() => Effect.succeed(getDefaultTypeMessage(e)))
+const formatTypeMessage = (issue: Type): Effect.Effect<string> =>
+  map(
+    getMessage(issue),
+    (message) => message ?? getParseIssueTitleAnnotation(issue) ?? getDefaultTypeMessage(issue)
   )
 
 const getParseIssueTitle = (
   issue: Forbidden | Transformation | Refinement | Composite
-): string => Option.getOrElse(getParseIssueTitleAnnotation(issue), () => String(issue.ast))
+): string => getParseIssueTitleAnnotation(issue) ?? String(issue.ast)
 
-const formatForbiddenMessage = (e: Forbidden): string => e.message ?? "is forbidden"
+const formatForbiddenMessage = (issue: Forbidden): string => issue.message ?? "is forbidden"
 
-const formatUnexpectedMessage = (e: Unexpected): string => e.message ?? "is unexpected"
+const formatUnexpectedMessage = (issue: Unexpected): string => issue.message ?? "is unexpected"
 
-const formatMissingMessage = (e: Missing): Effect.Effect<string> =>
-  AST.getMissingMessageAnnotation(e.ast).pipe(
-    Effect.flatMap((annotation) => {
-      const out = annotation()
-      return Predicate.isString(out) ? Effect.succeed(out) : out
-    }),
-    Effect.catchAll(() => Effect.succeed(e.message ?? "is missing"))
-  )
-
-const getTree = (issue: ParseIssue, onFailure: () => Effect.Effect<Tree<string>>) =>
-  Effect.matchEffect(getMessage(issue), {
-    onFailure,
-    onSuccess: (message) => Effect.succeed(makeTree(message))
-  })
+const formatMissingMessage = (issue: Missing): Effect.Effect<string> => {
+  const missingMessageAnnotation = AST.getMissingMessageAnnotation(issue.ast)
+  if (Option.isSome(missingMessageAnnotation)) {
+    const annotation = missingMessageAnnotation.value()
+    return Predicate.isString(annotation) ? Either.right(annotation) : annotation
+  }
+  return Either.right(issue.message ?? "is missing")
+}
 
-const formatTree = (
-  e: ParseIssue | Pointer
-): Effect.Effect<Tree<string>> => {
-  switch (e._tag) {
+const formatTree = (issue: ParseIssue): Effect.Effect<Tree<string>> => {
+  switch (issue._tag) {
     case "Type":
-      return Effect.map(formatTypeMessage(e), makeTree)
+      return map(formatTypeMessage(issue), makeTree)
     case "Forbidden":
-      return Effect.succeed(makeTree(getParseIssueTitle(e), [makeTree(formatForbiddenMessage(e))]))
+      return Either.right(makeTree(getParseIssueTitle(issue), [makeTree(formatForbiddenMessage(issue))]))
     case "Unexpected":
-      return Effect.succeed(makeTree(formatUnexpectedMessage(e)))
+      return Either.right(makeTree(formatUnexpectedMessage(issue)))
     case "Missing":
-      return Effect.map(formatMissingMessage(e), makeTree)
+      return map(formatMissingMessage(issue), makeTree)
     case "Transformation":
-      return getTree(e, () =>
-        Effect.map(
-          formatTree(e.issue),
-          (tree) => makeTree(getParseIssueTitle(e), [makeTree(formatTransformationKind(e.kind), [tree])])
-        ))
+      return flatMap(getMessage(issue), (message) => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message))
+        }
+        return map(
+          formatTree(issue.issue),
+          (tree) => makeTree(getParseIssueTitle(issue), [makeTree(formatTransformationKind(issue.kind), [tree])])
+        )
+      })
     case "Refinement":
-      return getTree(
-        e,
-        () =>
-          Effect.map(
-            formatTree(e.issue),
-            (tree) => makeTree(getParseIssueTitle(e), [makeTree(formatRefinementKind(e.kind), [tree])])
-          )
-      )
+      return flatMap(getMessage(issue), (message) => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message))
+        }
+        return map(
+          formatTree(issue.issue),
+          (tree) => makeTree(getParseIssueTitle(issue), [makeTree(formatRefinementKind(issue.kind), [tree])])
+        )
+      })
     case "Pointer":
-      return Effect.map(formatTree(e.issue), (tree) => makeTree(util_.formatPath(e.path), [tree]))
-    case "Composite": {
-      const parseIssueTitle = getParseIssueTitle(e)
-      return getTree(
-        e,
-        () =>
-          util_.isNonEmpty(e.issues)
-            ? Effect.map(Effect.forEach(e.issues, formatTree), (forest) => makeTree(parseIssueTitle, forest))
-            : Effect.map(formatTree(e.issues), (tree) => makeTree(parseIssueTitle, [tree]))
-      )
-    }
+      return map(formatTree(issue.issue), (tree) => makeTree(util_.formatPath(issue.path), [tree]))
+    case "Composite":
+      return flatMap(getMessage(issue), (message) => {
+        if (message !== undefined) {
+          return Either.right(makeTree(message))
+        }
+        const parseIssueTitle = getParseIssueTitle(issue)
+        return util_.isNonEmpty(issue.issues)
+          ? map(Effect.forEach(issue.issues, formatTree), (forest) => makeTree(parseIssueTitle, forest))
+          : map(formatTree(issue.issues), (tree) => makeTree(parseIssueTitle, [tree]))
+      })
   }
 }
 
@@ -2040,52 +2016,58 @@ export interface ArrayFormatterIssue {
   readonly message: string
 }
 
+const makeArrayFormatterIssue = (
+  _tag: ArrayFormatterIssue["_tag"],
+  path: ArrayFormatterIssue["path"],
+  message: ArrayFormatterIssue["message"]
+): ArrayFormatterIssue => ({ _tag, path, message })
+
 /**
  * @category formatting
  * @since 3.10.0
  */
 export const ArrayFormatter: ParseResultFormatter<Array<ArrayFormatterIssue>> = {
-  formatIssue: (issue) => formatArray(issue),
-  formatIssueSync: (issue) => Effect.runSync(ArrayFormatter.formatIssue(issue)),
+  formatIssue: (issue) => getArrayFormatterIssues(issue),
+  formatIssueSync: (issue) => {
+    const e = ArrayFormatter.formatIssue(issue)
+    return isEither(e) ? Either.getOrThrow(e) : Effect.runSync(e)
+  },
   formatError: (error) => ArrayFormatter.formatIssue(error.issue),
   formatErrorSync: (error) => ArrayFormatter.formatIssueSync(error.issue)
 }
 
-const succeedArrayFormatterIssue = (issue: ArrayFormatterIssue) => Effect.succeed([issue])
-
-const getArray = (
+const getArrayFormatterIssues = (
   issue: ParseIssue,
-  path: ReadonlyArray<PropertyKey>,
-  onFailure: () => Effect.Effect<Array<ArrayFormatterIssue>>
-) =>
-  Effect.matchEffect(getMessage(issue), {
-    onFailure,
-    onSuccess: (message) => succeedArrayFormatterIssue({ _tag: issue._tag, path, message })
-  })
-
-const formatArray = (
-  e: ParseIssue | Pointer,
   path: ReadonlyArray<PropertyKey> = []
 ): Effect.Effect<Array<ArrayFormatterIssue>> => {
-  const _tag = e._tag
+  const _tag = issue._tag
   switch (_tag) {
     case "Type":
-      return Effect.map(formatTypeMessage(e), (message) => [{ _tag, path, message }])
+      return map(formatTypeMessage(issue), (message) => [makeArrayFormatterIssue(_tag, path, message)])
     case "Forbidden":
-      return succeedArrayFormatterIssue({ _tag, path, message: formatForbiddenMessage(e) })
+      return Either.right([makeArrayFormatterIssue(_tag, path, formatForbiddenMessage(issue))])
     case "Unexpected":
-      return succeedArrayFormatterIssue({ _tag, path, message: formatUnexpectedMessage(e) })
+      return Either.right([makeArrayFormatterIssue(_tag, path, formatUnexpectedMessage(issue))])
     case "Missing":
-      return Effect.map(formatMissingMessage(e), (message) => [{ _tag, path, message }])
+      return map(formatMissingMessage(issue), (message) => [makeArrayFormatterIssue(_tag, path, message)])
     case "Pointer":
-      return formatArray(e.issue, path.concat(e.path))
+      return getArrayFormatterIssues(issue.issue, path.concat(issue.path))
     case "Composite":
-      return getArray(e, path, () =>
-        util_.isNonEmpty(e.issues)
-          ? Effect.map(Effect.forEach(e.issues, (issue) => formatArray(issue, path)), Arr.flatten)
-          : formatArray(e.issues, path))
+      return flatMap(getMessage(issue), (message) => {
+        if (message !== undefined) {
+          return Either.right([makeArrayFormatterIssue(issue._tag, path, message)])
+        }
+        return util_.isNonEmpty(issue.issues)
+          ? map(Effect.forEach(issue.issues, (issue) => getArrayFormatterIssues(issue, path)), Arr.flatten)
+          : getArrayFormatterIssues(issue.issues, path)
+      })
     case "Refinement":
     case "Transformation":
-      return getArray(e, path, () => formatArray(e.issue, path))
+      return flatMap(getMessage(issue), (message) => {
+        if (message !== undefined) {
+          return Either.right([makeArrayFormatterIssue(issue._tag, path, message)])
+        }
+        return getArrayFormatterIssues(issue.issue, path)
+      })
   }
 }

package/src/STM.ts

@@ -81,7 +81,7 @@ export interface STM<out A, out E = never, out R = never>
  * @category models
  */
 export interface STMUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
-  STM?: () => A[Unify.typeSymbol] extends STM<infer A0, infer E0, infer R0> | infer _ ? STM<R0, E0, A0> : never
+  STM?: () => A[Unify.typeSymbol] extends STM<infer A0, infer E0, infer R0> | infer _ ? STM<A0, E0, R0> : never
 }
 
 /**

package/src/Schema.ts

@@ -2,7 +2,6 @@
  * @since 3.10.0
  */
 
-import * as internalCause_ from "effect/internal/cause"
 import type { ArbitraryAnnotation, ArbitraryGenerationContext, LazyArbitrary } from "./Arbitrary.js"
 import * as array_ from "./Array.js"
 import * as bigDecimal_ from "./BigDecimal.js"
@@ -29,6 +28,7 @@ import { dual, identity } from "./Function.js"
 import { globalValue } from "./GlobalValue.js"
 import * as hashMap_ from "./HashMap.js"
 import * as hashSet_ from "./HashSet.js"
+import * as internalCause_ from "./internal/cause.js"
 import * as errors_ from "./internal/schema/errors.js"
 import * as schemaId_ from "./internal/schema/schemaId.js"
 import * as util_ from "./internal/schema/util.js"

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.12.8"
+let moduleVersion = "3.12.10"
 
 export const getCurrentVersion = () => moduleVersion