simplify error aggregation

Author: neverRare

misc/misc.ts

@@ -24,13 +24,6 @@ export function repeatArray<T>(element: T, count: number): ReadonlyArray<T> {
 export function repeatWithSpace(text: string, count: number): string {
   return repeatArray(text, count).join(" ");
 }
-export function flattenError(error: unknown): ReadonlyArray<unknown> {
-  if (error instanceof AggregateError) {
-    return error.errors.flatMap(flattenError);
-  } else {
-    return [error];
-  }
-}
 export function throwError(error: unknown): never {
   throw error;
 }

src/array_result.ts

@@ -1,4 +1,4 @@
-import { flattenError, nullableAsArray } from "../misc/misc.ts";
+import { nullableAsArray } from "../misc/misc.ts";
 
 export type ArrayResultOptions = {
   cause: unknown;
@@ -132,40 +132,23 @@ export class ArrayResult<T> {
     try {
       return arrayResult();
     } catch (error) {
-      return ArrayResult.errors(extractArrayResultError(flattenError(error)));
+      return ArrayResult.errors(extractArrayResultError(error));
     }
   }
 }
-type Errors =
-  | Readonly<{ type: "array result"; errors: ReadonlyArray<ArrayResultError> }>
-  | Readonly<{ type: "outside"; errors: ReadonlyArray<unknown> }>;
 export function extractArrayResultError(
-  errors: ReadonlyArray<unknown>,
+  error: unknown,
 ): ReadonlyArray<ArrayResultError> {
-  const aggregate = errors.reduce<Errors>(
-    (errors, error) => {
-      switch (errors.type) {
-        case "array result":
-          if (error instanceof ArrayResultError) {
-            return { type: "array result", errors: [...errors.errors, error] };
-          } else {
-            return { type: "outside", errors: [error] };
-          }
-        case "outside": {
-          const moreError = error instanceof ArrayResultError ? [] : [error];
-          return { type: "outside", errors: [...errors.errors, ...moreError] };
-        }
-      }
-    },
-    {
-      type: "array result",
-      errors: [],
-    },
-  );
-  switch (aggregate.type) {
-    case "array result":
-      return aggregate.errors;
-    case "outside":
-      throw new AggregateError(aggregate.errors);
+  if (error instanceof ArrayResultError) {
+    return [error];
+  } else if (error instanceof AggregateError) {
+    const { errors } = error;
+    if (
+      errors.length > 1 &&
+      errors.every((error) => error instanceof ArrayResultError)
+    ) {
+      return errors;
+    }
   }
+  throw error;
 }

src/parser/filter.ts

@@ -1,4 +1,4 @@
-import { compound, flattenError, throwError } from "../../misc/misc.ts";
+import { compound, throwError } from "../../misc/misc.ts";
 import { extractArrayResultError } from "../array_result.ts";
 import { settings } from "../settings.ts";
 import {
@@ -373,23 +373,18 @@ export function filter<T>(
             return [];
           }
         } catch (error) {
-          return flattenError(error);
+          return extractArrayResultError(error);
         }
       },
     );
     if (result.every((result) => result == null)) {
       return true;
     } else {
-      const errors = extractArrayResultError(
-        result.flatMap((result) => result ?? []),
-      );
-      switch (errors.length) {
-        case 0:
-          return false;
-        case 1:
-          throw errors[0];
-        default:
-          throw new AggregateError(errors);
+      const errors = result.flatMap((result) => result ?? []);
+      if (errors.length === 0) {
+        return false;
+      } else {
+        throw new AggregateError(errors);
       }
     }
   };