better parameters

Author: neverRare

src/dictionary/parallel_parser.ts

@@ -4,12 +4,12 @@ import { HEADS } from "./parser.ts";
 import { Dictionary } from "./type.ts";
 
 type WorkerError =
-  | Readonly<
-    {
-      type: "positioned error";
-      errors: ReadonlyArray<Position & Readonly<{ message: string }>>;
-    }
-  >
+  | Readonly<{
+    type: "result error";
+    errors: ReadonlyArray<
+      Readonly<{ message: string; position: null | Position }>
+    >;
+  }>
   | Readonly<{ type: "other"; error: unknown }>;
 
 function buildOffloaded(source: string): Promise<Dictionary> {
@@ -26,11 +26,14 @@ function buildOffloaded(source: string): Promise<Dictionary> {
     worker.onerror = (event) => {
       const error = event.error as WorkerError;
       switch (error.type) {
-        case "positioned error":
+        case "result error":
           reject(
             new AggregateError(
               error.errors.map((error) =>
-                new PositionedError(error.message, error)
+                new PositionedError(
+                  error.message,
+                  { position: error.position ?? undefined },
+                )
               ),
             ),
           );
@@ -74,8 +77,10 @@ export async function parseDictionary(source: string): Promise<Dictionary> {
         ) {
           errors.push(
             new PositionedError(resultError.message, {
-              position: job.index + resultError.position.position,
-              length: resultError.position.length,
+              position: {
+                position: job.index + resultError.position.position,
+                length: resultError.position.length,
+              },
               cause: resultError,
             }),
           );

src/dictionary/parser.ts

@@ -656,7 +656,7 @@ const dictionaryParser: Parser<Dictionary> = ignore
         errors.push(
           new PositionedError(
             `duplicate Toki Pona word "${head.value}"`,
-            head,
+            { position: head },
           ),
         );
       } else {

src/dictionary/worker.ts

@@ -1,4 +1,5 @@
-import { extractResultError, ResultError } from "../compound.ts";
+import { extractResultError, type ResultError } from "../compound.ts";
+import { type PositionedError } from "../parser/parser_lib.ts";
 import { parseDictionary } from "./parser.ts";
 
 onmessage = (message) => {
@@ -12,8 +13,11 @@ onmessage = (message) => {
       throw { type: "other", error };
     }
     throw {
-      type: "positioned error",
-      error: errors.map((error) => ({ ...error })),
+      type: "result error",
+      error: errors.map((error) => ({
+        message: error.message,
+        position: (error as PositionedError).position,
+      })),
     };
   }
 };

src/parser/parser_lib.ts

@@ -1,7 +1,7 @@
 import { assertGreater } from "@std/assert/greater";
 import { MemoizationCacheResult, memoize } from "@std/cache/memoize";
 import { IterableResult, ResultError } from "../compound.ts";
-import { ErrorOption, lazy as lazyEval } from "../misc/misc.ts";
+import { lazy as lazyEval } from "../misc/misc.ts";
 
 type ValueLength<T> = Readonly<{ value: T; length: number }>;
 type ParserResult<T> = IterableResult<ValueLength<T>>;
@@ -101,16 +101,19 @@ export class Parser<T> {
   }
 }
 export type Position = Readonly<{ position: number; length: number }>;
+export type PositionedErrorOption = Readonly<{
+  position?: Position;
+  cause?: unknown;
+}>;
 export class PositionedError extends ResultError {
   override name = "PositionedError";
   position: null | Position;
   constructor(
     message: string,
-    // TODO: it's better to separate these two instead
-    option?: Position & ErrorOption,
+    option?: PositionedErrorOption,
   ) {
     super(message, option);
-    this.position = option ?? null;
+    this.position = option?.position ?? null;
   }
 }
 function withPositionedError<T>(fn: () => T, position: Position) {
@@ -120,7 +123,7 @@ function withPositionedError<T>(fn: () => T, position: Position) {
     if (error instanceof PositionedError && error.position != null) {
       throw error;
     } else if (error instanceof ResultError) {
-      throw new PositionedError(error.message, { ...position, cause: error });
+      throw new PositionedError(error.message, { position, cause: error });
     } else {
       throw error;
     }
@@ -131,7 +134,7 @@ export class UnexpectedError extends PositionedError {
   constructor(
     unexpected: string,
     expected: string,
-    option?: Position & ErrorOption,
+    option?: PositionedErrorOption,
   ) {
     super(
       `unexpected ${unexpected}. ${expected} were expected instead`,
@@ -141,7 +144,7 @@ export class UnexpectedError extends PositionedError {
 }
 export class UnrecognizedError extends PositionedError {
   override name = "UnrecognizedError";
-  constructor(element: string, option?: Position & ErrorOption) {
+  constructor(element: string, option?: PositionedErrorOption) {
     super(`${element} is unrecognized`, option);
   }
 }
@@ -279,7 +282,11 @@ function generateError(position: number, expected: string) {
     }
   }
   return IterableResult.errors([
-    new UnexpectedError(unexpected, expected, { position, length }),
+    new UnexpectedError(
+      unexpected,
+      expected,
+      { position: { position, length } },
+    ),
   ]);
 }
 export function matchCapture(
@@ -338,7 +345,7 @@ export const notEnd: Parser<null> = new Parser((position) =>
       new UnexpectedError(
         "end of text",
         "not end of text",
-        { position, length: currentSource.length - position },
+        { position: { position, length: currentSource.length - position } },
       ),
     ])
 );