add iterable variant to array result

neverRare · neverRare · commit cde883419136 · 2025-04-27T15:20:00.000+08:00
diff --git a/dictionary/build.ts b/dictionary/build.ts
@@ -2,7 +2,7 @@
 
 // deno-lint-ignore-file no-console
 
-import { ArrayResultError } from "../src/array_result.ts";
+import { ResultError } from "../src/array_result.ts";
 import { PositionedError } from "../src/parser/parser_lib.ts";
 import { dictionaryParser } from "./parser.ts";
 import { Dictionary } from "./type.ts";
@@ -50,7 +50,7 @@ export async function build(): Promise<boolean> {
   );
   return true;
 }
-function displayError(source: string, errors: ReadonlyArray<ArrayResultError>) {
+function displayError(source: string, errors: ReadonlyArray<ResultError>) {
   let color: boolean;
   try {
     color = Deno.env.get("NO_COLOR") !== "1";
diff --git a/src/array_result.ts b/src/array_result.ts
@@ -4,28 +4,28 @@ export type ArrayResultOptions = {
   cause: unknown;
   isHtml: boolean;
 };
-export class ArrayResultError extends Error {
+export class ResultError extends Error {
   isHtml: boolean;
   override name = "ArrayResultError";
   constructor(message: string, options: Partial<ArrayResultOptions> = {}) {
     super(message, { cause: options.cause });
     this.isHtml = options.isHtml ?? false;
   }
 }
-export class TodoError extends ArrayResultError {
+export class TodoError extends ResultError {
   override name = "TodoError";
   constructor(functionality: string) {
     super(`${functionality} is not yet implemented`);
   }
 }
 export class ArrayResult<const T> {
   constructor(array?: ReadonlyArray<T>);
-  constructor(array: undefined, errors: ReadonlyArray<ArrayResultError>);
+  constructor(array: undefined, errors: ReadonlyArray<ResultError>);
   constructor(
     public readonly array: ReadonlyArray<T> = [],
-    public readonly errors: ReadonlyArray<ArrayResultError> = [],
+    public readonly errors: ReadonlyArray<ResultError> = [],
   ) {}
-  static errors(errors: ReadonlyArray<ArrayResultError>): ArrayResult<never> {
+  static errors(errors: ReadonlyArray<ResultError>): ArrayResult<never> {
     return new ArrayResult(undefined, errors);
   }
   static empty(): ArrayResult<never> {
@@ -75,13 +75,20 @@ export class ArrayResult<const T> {
   sortBy(mapper: (value: T) => number): ArrayResult<T> {
     return this.sort((left, right) => mapper(left) - mapper(right));
   }
-  addErrorWhenNone(error: () => ArrayResultError): ArrayResult<T> {
+  addErrorWhenNone(error: () => ResultError): ArrayResult<T> {
     if (this.isError() && this.errors.length === 0) {
       return ArrayResult.errors([error()]);
     } else {
       return this;
     }
   }
+  asIterableResult(): IterableResult<T> {
+    if (this.isError()) {
+      return IterableResult.errors(this.errors);
+    } else {
+      return IterableResult.fromArray(this.unwrap());
+    }
+  }
   static concat<T>(
     ...arrayResults: ReadonlyArray<ArrayResult<T>>
   ): ArrayResult<T> {
@@ -118,20 +125,204 @@ export class ArrayResult<const T> {
     try {
       return arrayResult();
     } catch (error) {
-      return ArrayResult.errors(extractArrayResultError(error));
+      return ArrayResult.errors(extractResultError(error));
+    }
+  }
+}
+export type Result<T> =
+  | Readonly<{ type: "value"; value: T }>
+  | Readonly<{ type: "error"; error: ResultError }>;
+
+export class IterableResult<const T> {
+  constructor(public readonly iterable: () => Generator<Result<T>>) {}
+  static fromArray<const T>(array: ReadonlyArray<T>): IterableResult<T> {
+    return new IterableResult(function* () {
+      for (const value of array) {
+        yield { type: "value", value };
+      }
+    });
+  }
+  static single<const T>(value: T): IterableResult<T> {
+    return new IterableResult(function* () {
+      yield { type: "value", value };
+    });
+  }
+  static errors(errors: ReadonlyArray<ResultError>): IterableResult<never> {
+    return new IterableResult(function* () {
+      for (const error of errors) {
+        yield { type: "error", error };
+      }
+    });
+  }
+  static empty(): IterableResult<never> {
+    return new IterableResult(function* () {});
+  }
+  filter(mapper: (value: T) => boolean): IterableResult<T> {
+    return this.flatMap((value) =>
+      mapper(value) ? IterableResult.single(value) : IterableResult.empty()
+    );
+  }
+  map<const U>(mapper: (value: T) => U): IterableResult<U> {
+    return this.flatMap((value) => IterableResult.single(mapper(value)));
+  }
+  flatMap<const U>(mapper: (value: T) => IterableResult<U>): IterableResult<U> {
+    const iterable = this.iterable;
+    return new IterableResult(function* () {
+      const errors: Array<ResultError> = [];
+      let yielded = false;
+      for (const result of iterable()) {
+        switch (result.type) {
+          case "value": {
+            const more = IterableResult.from(() => mapper(result.value));
+            for (const result of more.iterable()) {
+              switch (result.type) {
+                case "value":
+                  yielded = false;
+                  yield result;
+                  break;
+                case "error":
+                  errors.push(result.error);
+              }
+            }
+            break;
+          }
+          case "error":
+            yield result;
+        }
+      }
+      if (!yielded) {
+        for (const error of errors) {
+          yield { type: "error", error } as const;
+        }
+      }
+    });
+  }
+  filterMap<const U>(mapper: (value: T) => U): IterableResult<NonNullable<U>> {
+    return this.flatMap((value) => {
+      const newValue = mapper(value);
+      if (newValue == null) {
+        return IterableResult.empty();
+      } else {
+        return IterableResult.single(newValue);
+      }
+    });
+  }
+  addErrorWhenNone(error: () => ResultError): IterableResult<T> {
+    const iterable = this.iterable;
+    return new IterableResult(function* () {
+      let yielded = false;
+      for (const result of iterable()) {
+        yielded = true;
+        yield result;
+      }
+      if (!yielded) {
+        yield { type: "error", error: error() };
+      }
+    });
+  }
+  static concat<T>(
+    ...iterableResults: ReadonlyArray<IterableResult<T>>
+  ): IterableResult<T> {
+    return new IterableResult(function* () {
+      const errors: Array<ResultError> = [];
+      let yielded = false;
+      for (const iterable of iterableResults) {
+        for (const result of iterable.iterable()) {
+          switch (result.type) {
+            case "value":
+              yielded = true;
+              yield result;
+              break;
+            case "error":
+              errors.push(result.error);
+              break;
+          }
+        }
+      }
+      if (!yielded) {
+        for (const error of errors) {
+          yield { type: "error", error } as const;
+        }
+      }
+    });
+  }
+  static combine<T extends ReadonlyArray<unknown>>(
+    ...iterableResults:
+      & Readonly<{ [I in keyof T]: IterableResult<T[I]> }>
+      & Readonly<{ length: T["length"] }>
+  ): IterableResult<T> {
+    // we resorted to using `any` types here, make sure it works properly
+    return iterableResults.reduce(
+      (left: IterableResult<any>, right) =>
+        new IterableResult(function* () {
+          let rightAggregate: null | Array<any> = null;
+          let yielded = false;
+          for (const leftResult of left.iterable()) {
+            switch (leftResult.type) {
+              case "value":
+                if (rightAggregate == null) {
+                  rightAggregate = [];
+                  for (const rightResult of right.iterable()) {
+                    switch (rightResult.type) {
+                      case "value": {
+                        const right = rightResult.value;
+                        rightAggregate.push(right);
+                        yielded = true;
+                        yield {
+                          type: "value",
+                          value: [...leftResult.value, right],
+                        };
+                        break;
+                      }
+                      case "error":
+                        yield rightResult;
+                        break;
+                    }
+                  }
+                } else {
+                  for (const right of rightAggregate) {
+                    yielded = true;
+                    yield {
+                      type: "value",
+                      value: [...leftResult.value, right],
+                    };
+                  }
+                }
+                break;
+              case "error":
+                yield leftResult;
+                break;
+            }
+          }
+          if (!yielded && rightAggregate == null) {
+            for (const result of right.iterable()) {
+              if (result.type === "error") {
+                yield result;
+              }
+            }
+          }
+        }),
+      IterableResult.single([]) as IterableResult<any>,
+    ) as IterableResult<T>;
+  }
+  static from<T>(iterableResult: () => IterableResult<T>): IterableResult<T> {
+    try {
+      return iterableResult();
+    } catch (error) {
+      return IterableResult.errors(extractResultError(error));
     }
   }
 }
-export function extractArrayResultError(
+export function extractResultError(
   error: unknown,
-): ReadonlyArray<ArrayResultError> {
-  if (error instanceof ArrayResultError) {
+): ReadonlyArray<ResultError> {
+  if (error instanceof ResultError) {
     return [error];
   } else if (error instanceof AggregateError) {
     const { errors } = error;
     if (
       errors.length > 0 &&
-      errors.every((error) => error instanceof ArrayResultError)
+      errors.every((error) => error instanceof ResultError)
     ) {
       return errors;
     }
diff --git a/src/parser/filter.ts b/src/parser/filter.ts
@@ -1,5 +1,5 @@
 import { compound, throwError } from "../../misc/misc.ts";
-import { extractArrayResultError } from "../array_result.ts";
+import { extractResultError } from "../array_result.ts";
 import { settings } from "../settings.ts";
 import {
   Clause,
@@ -376,7 +376,7 @@ export function filter<const T>(
             return [];
           }
         } catch (error) {
-          return extractArrayResultError(error);
+          return extractResultError(error);
         }
       },
     );
diff --git a/src/parser/parser_lib.ts b/src/parser/parser_lib.ts
@@ -1,7 +1,7 @@
 import { assertGreater } from "@std/assert/greater";
 import { MemoizationCacheResult, memoize } from "@std/cache/memoize";
 import { lazy as lazyEval } from "../../misc/misc.ts";
-import { ArrayResult, ArrayResultError } from "../array_result.ts";
+import { ArrayResult, ResultError } from "../array_result.ts";
 
 type ParserResult<T> = ArrayResult<Readonly<{ value: T; length: number }>>;
 type InnerParser<T> = (input: number) => ParserResult<T>;
@@ -82,7 +82,7 @@ export class Parser<const T> {
   }
 }
 export type Position = Readonly<{ position: number; length: number }>;
-export class PositionedError extends ArrayResultError {
+export class PositionedError extends ResultError {
   public position: null | Position;
   override name = "PositionedError";
   constructor(message: string, position?: Position) {
@@ -116,7 +116,7 @@ export class UnrecognizedError extends PositionedError {
     super(`${element} is unrecognized`, position);
   }
 }
-export function error(error: ArrayResultError): Parser<never> {
+export function error(error: ResultError): Parser<never> {
   return new Parser(() => ArrayResult.errors([error]));
 }
 export const empty: Parser<never> = new Parser(() => ArrayResult.empty());
@@ -365,7 +365,7 @@ export function choiceWithCheck<const T>(
   ...choices: ReadonlyArray<CheckedParser<T>>
 ): Parser<T> {
   return new Parser((position) => {
-    const errors: Array<ArrayResultError> = [];
+    const errors: Array<ResultError> = [];
     for (const { check, parser } of choices) {
       const result = check.rawParser(position);
       if (result.isError()) {
diff --git a/src/translator/error.ts b/src/translator/error.ts
@@ -1,24 +1,24 @@
-import { ArrayResultError, TodoError } from "../array_result.ts";
+import { ResultError, TodoError } from "../array_result.ts";
 
 export class TranslationTodoError extends TodoError {
   override name = "TranslationTodoError";
   constructor(type: string) {
     super(`translation of ${type}`);
   }
 }
-export class ExhaustedError extends ArrayResultError {
+export class ExhaustedError extends ResultError {
   override name = "ExhaustedError";
   constructor(text: string) {
     super(`no possible translation found for "${text}"`);
   }
 }
-export class FilteredError extends ArrayResultError {
+export class FilteredError extends ResultError {
   override name = "FilteredOutError";
   constructor(element: string) {
     super(`${element} is filtered out`);
   }
 }
-export class UntranslatableError extends ArrayResultError {
+export class UntranslatableError extends ResultError {
   override name = "UntranslatableError";
   constructor(source: string, target: string) {
     super(`cannot translate ${source} into ${target}`);
diff --git a/src/translator/translator.ts b/src/translator/translator.ts
@@ -2,7 +2,7 @@ import { distinct } from "@std/collections/distinct";
 import { distinctBy } from "@std/collections/distinct-by";
 import { shuffle } from "@std/random/shuffle";
 import { errors } from "../../telo_misikeke/telo_misikeke.js";
-import { ArrayResult, ArrayResultError } from "../array_result.ts";
+import { ArrayResult, ResultError } from "../array_result.ts";
 import { parser } from "../parser/parser.ts";
 import { settings } from "../settings.ts";
 import * as EnglishComposer from "./composer.ts";
@@ -23,7 +23,7 @@ export function translate(tokiPona: string): ArrayResult<string> {
   } else {
     const teloMisikekeErrors = settings.teloMisikeke
       ? errors(tokiPona)
-        .map((message) => new ArrayResultError(message, { isHtml: true }))
+        .map((message) => new ResultError(message, { isHtml: true }))
       : [];
     const error = teloMisikekeErrors.length === 0
       ? deduplicateErrors(arrayResult.errors)

Original file line number	Diff line number	Diff line change
`@@ -1,24 +1,24 @@`
`1`		`-import { ArrayResultError, TodoError } from "../array_result.ts";`
	`1`	`+import { ResultError, TodoError } from "../array_result.ts";`
`2`	`2`
`3`	`3`	`export class TranslationTodoError extends TodoError {`
`4`	`4`	`override name = "TranslationTodoError";`
`5`	`5`	`constructor(type: string) {`
`6`	`6`	super(`translation of ${type}`);
`7`	`7`	`}`
`8`	`8`	`}`
`9`		`-export class ExhaustedError extends ArrayResultError {`
	`9`	`+export class ExhaustedError extends ResultError {`
`10`	`10`	`override name = "ExhaustedError";`
`11`	`11`	`constructor(text: string) {`
`12`	`12`	super(`no possible translation found for "${text}"`);
`13`	`13`	`}`
`14`	`14`	`}`
`15`		`-export class FilteredError extends ArrayResultError {`
	`15`	`+export class FilteredError extends ResultError {`
`16`	`16`	`override name = "FilteredOutError";`
`17`	`17`	`constructor(element: string) {`
`18`	`18`	super(`${element} is filtered out`);
`19`	`19`	`}`
`20`	`20`	`}`
`21`		`-export class UntranslatableError extends ArrayResultError {`
	`21`	`+export class UntranslatableError extends ResultError {`
`22`	`22`	`override name = "UntranslatableError";`
`23`	`23`	`constructor(source: string, target: string) {`
`24`	`24`	super(`cannot translate ${source} into ${target}`);