make use of lazy iteration

Author: neverRare

src/compound.ts

@@ -157,6 +157,25 @@ export class IterableResult<const T> {
   static empty(): IterableResult<never> {
     return new IterableResult(function* () {});
   }
+  collect(): ReadonlyArray<T> {
+    const array: Array<T> = [];
+    const error: Array<ResultError> = [];
+    for (const result of this.iterable()) {
+      switch (result.type) {
+        case "value":
+          array.push(result.value);
+          break;
+        case "error":
+          error.push(result.error);
+          break;
+      }
+    }
+    if (error.length > 0) {
+      throw new AggregateError(error);
+    } else {
+      return array;
+    }
+  }
   filter(mapper: (value: T) => boolean): IterableResult<T> {
     return this.flatMap((value) =>
       mapper(value) ? IterableResult.single(value) : IterableResult.empty()

src/main.ts

@@ -23,6 +23,7 @@ import {
   resetElementsToDefault,
 } from "./settings_frontend.ts";
 import { translate } from "./translator/translator.ts";
+import { ResultError } from "./compound.ts";
 
 const DICTIONARY_AUTO_PARSE_THRESHOLD = 9000;
 
@@ -243,15 +244,24 @@ function main() {
     outputList.innerHTML = "";
     errorList.innerHTML = "";
     errorDisplay.innerText = "";
-    const result = translate(inputTextBox.value);
-    if (!result.isError()) {
-      for (const translation of result.unwrap()) {
-        const list = document.createElement("li");
-        list.innerHTML = translation;
-        outputList.appendChild(list);
+    const iterableResult = translate(inputTextBox.value);
+    const errors: Array<ResultError> = [];
+    let yielded = false;
+    for (const result of iterableResult.iterable()) {
+      switch (result.type) {
+        case "value": {
+          yielded = true;
+          const list = document.createElement("li");
+          list.innerHTML = result.value;
+          outputList.appendChild(list);
+          break;
+        }
+        case "error":
+          errors.push(result.error);
+          break;
       }
-    } else {
-      const errors = result.errors;
+    }
+    if (!yielded) {
       switch (errors.length) {
         case 0:
           errorDisplay.innerText = UNKNOWN_ERROR_MESSAGE;

src/repl.ts

@@ -15,23 +15,33 @@ if (import.meta.main) {
     if (input == null) {
       break;
     }
-    const result = translate(input);
-    if (result.isError()) {
-      // deno-lint-ignore no-console
-      console.error(new AggregateError(result.errors));
-    } else {
-      const translations = result.unwrap();
-      for (const translation of translations) {
-        const count = translation.match(/<strong>/g)?.length ?? 0;
-        const text = unescape(
-          translation.replaceAll(/<\/?strong>/g, "%c"),
-          { entityList },
-        );
-        // deno-lint-ignore no-console
-        console.log(
-          `  - ${text}`,
-          ...repeatArray(["font-weight: bold", ""], count).flat(),
-        );
+    const iterableResult = translate(input);
+    let errorHeaderShown = false;
+    for (const result of iterableResult.iterable()) {
+      switch (result.type) {
+        case "value": {
+          const translation = result.value;
+          const count = translation.match(/<strong>/g)?.length ?? 0;
+          const text = unescape(
+            translation.replaceAll(/<\/?strong>/g, "%c"),
+            { entityList },
+          );
+          // deno-lint-ignore no-console
+          console.log(
+            `  - ${text}`,
+            ...repeatArray(["font-weight: bold", ""], count).flat(),
+          );
+          break;
+        }
+        case "error": {
+          if (!errorHeaderShown) {
+            // deno-lint-ignore no-console
+            console.error("Errors have occurred:");
+            errorHeaderShown = true;
+          }
+          // deno-lint-ignore no-console
+          console.error(`- ${result.error.message}`);
+        }
       }
     }
   }

src/translator/adjective.ts

@@ -1,6 +1,6 @@
 import * as Dictionary from "../../dictionary/type.ts";
 import { nullableAsArray } from "../../misc/misc.ts";
-import { ArrayResult } from "../compound.ts";
+import { IterableResult } from "../compound.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { UntranslatableError } from "./error.ts";
@@ -28,12 +28,12 @@ export function adjective(
     reduplicationCount: number;
     emphasis: null | TokiPona.Emphasis;
   }>,
-): ArrayResult<English.AdjectivePhrase & { type: "simple" }> {
+): IterableResult<English.AdjectivePhrase & { type: "simple" }> {
   const { definition, reduplicationCount, emphasis } = options;
-  return ArrayResult.concat<{ emphasis: boolean; so: null | string }>(
-    ArrayResult.from(() => new ArrayResult([so(emphasis)]))
+  return IterableResult.concat<{ emphasis: boolean; so: null | string }>(
+    IterableResult.from(() => IterableResult.single(so(emphasis)))
       .map((so) => ({ emphasis: false, so })),
-    new ArrayResult([{ emphasis: emphasis != null, so: null }]),
+    IterableResult.single({ emphasis: emphasis != null, so: null }),
   )
     .map(({ emphasis, so }) => ({
       type: "simple",
@@ -53,10 +53,10 @@ export function compoundAdjective(
     reduplicationCount: number;
     emphasis: null | TokiPona.Emphasis;
   }>,
-): ArrayResult<English.AdjectivePhrase & { type: "compound" }> {
+): IterableResult<English.AdjectivePhrase & { type: "compound" }> {
   const { adjectives, reduplicationCount, emphasis } = options;
   if (reduplicationCount === 1) {
-    return ArrayResult.combine(
+    return IterableResult.combine(
       ...adjectives
         .map((definition) =>
           adjective({ definition, reduplicationCount: 1, emphasis })
@@ -69,7 +69,7 @@ export function compoundAdjective(
         emphasis: false,
       }));
   } else {
-    return ArrayResult.errors([
+    return IterableResult.errors([
       new UntranslatableError("reduplication", "compound adjective"),
     ]);
   }

src/translator/as_string.ts

@@ -1,5 +1,5 @@
 import * as Dictionary from "../../dictionary/type.ts";
-import { ArrayResult } from "../compound.ts";
+import { IterableResult } from "../compound.ts";
 import { adjective, compoundAdjective } from "./adjective.ts";
 import * as EnglishComposer from "./composer.ts";
 import { nounAsPlainString, simpleNounForms } from "./noun.ts";
@@ -8,12 +8,12 @@ import { partialVerb, verb } from "./verb.ts";
 
 export function definitionAsPlainString(
   definition: Dictionary.Definition,
-): ArrayResult<string> {
+): IterableResult<string> {
   switch (definition.type) {
     case "noun":
       return nounAsPlainString(definition);
     case "personal pronoun":
-      return ArrayResult.concat(
+      return IterableResult.concat(
         pronoun({
           definition,
           reduplicationCount: 1,
@@ -45,9 +45,9 @@ export function definitionAsPlainString(
         plural: definition.plural,
       });
     case "adverb":
-      return new ArrayResult([definition.adverb]);
+      return IterableResult.single(definition.adverb);
     case "interjection":
-      return new ArrayResult([definition.interjection]);
+      return IterableResult.single(definition.interjection);
     case "verb": {
       return partialVerb({ definition, reduplicationCount: 1, emphasis: false })
         .flatMap((partialVerb) =>
@@ -56,19 +56,19 @@ export function definitionAsPlainString(
         .map((verb) => EnglishComposer.verb(verb, 0));
     }
     case "filler":
-      return new ArrayResult([
+      return IterableResult.single(
         `${definition.before}${definition.repeat}${definition.after}`,
-      ]);
+      );
     case "particle definition":
-      return new ArrayResult([definition.definition]);
+      return IterableResult.single(definition.definition);
     case "noun preposition":
       return nounAsPlainString(definition.noun)
         .map((noun) => `${noun} ${definition.preposition}`);
     case "numeral":
-      return new ArrayResult([`${definition.numeral}`]);
+      return IterableResult.single(`${definition.numeral}`);
     case "preposition":
-      return new ArrayResult([definition.preposition]);
+      return IterableResult.single(definition.preposition);
     case "modal verb":
-      return new ArrayResult([definition.verb]);
+      return IterableResult.single(definition.verb);
   }
 }

src/translator/clause.ts

@@ -1,5 +1,5 @@
 import { nullableAsArray, throwError } from "../../misc/misc.ts";
-import { ArrayResult } from "../compound.ts";
+import { IterableResult } from "../compound.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { FilteredError, TranslationTodoError } from "./error.ts";
@@ -71,7 +71,7 @@ function phraseClause(phrases: TokiPona.MultiplePhrases) {
     });
 }
 function liClause(clause: TokiPona.Clause & { type: "li clause" }) {
-  return ArrayResult.combine(
+  return IterableResult.combine(
     multiplePhrasesAsNoun({
       phrases: clause.subjects,
       place: "subject",
@@ -134,27 +134,25 @@ function oClause(clause: TokiPona.Clause & { type: "o clause" }) {
       includeGerund: true,
       andParticle: "en",
     })
-    : new ArrayResult([
-      {
-        type: "simple",
-        determiner: [],
-        adjective: [],
-        noun: noEmphasis("you"),
-        quantity: "plural",
-        perspective: "second",
-        postAdjective: null,
-        postCompound: null,
-        preposition: [],
-        emphasis: false,
-      },
-    ]);
-  return ArrayResult.combine(subject, predicate(clause.predicates, "o"))
+    : IterableResult.single({
+      type: "simple",
+      determiner: [],
+      adjective: [],
+      noun: noEmphasis("you"),
+      quantity: "plural",
+      perspective: "second",
+      postAdjective: null,
+      postCompound: null,
+      preposition: [],
+      emphasis: false,
+    });
+  return IterableResult.combine(subject, predicate(clause.predicates, "o"))
     .flatMap(([subject, predicate]) => {
       const subjectPerspective = perspective(subject);
-      return ArrayResult.concat(
+      return IterableResult.concat(
         verb(predicate, subjectPerspective, subject.quantity)
           .map((verb) => iWish(subject, verb)),
-        ArrayResult.from(() =>
+        IterableResult.from(() =>
           verb(
             addModalToAll(
               noAdverbs(noEmphasis("should")),
@@ -173,7 +171,9 @@ function oClause(clause: TokiPona.Clause & { type: "o clause" }) {
       );
     });
 }
-export function clause(clause: TokiPona.Clause): ArrayResult<English.Clause> {
+export function clause(
+  clause: TokiPona.Clause,
+): IterableResult<English.Clause> {
   switch (clause.type) {
     case "phrases":
       return phraseClause(clause.phrases);
@@ -200,10 +200,12 @@ export function clause(clause: TokiPona.Clause): ArrayResult<English.Clause> {
 }
 export function contextClause(
   contextClause: TokiPona.ContextClause,
-): ArrayResult<ReadonlyArray<English.Clause>> {
+): IterableResult<ReadonlyArray<English.Clause>> {
   switch (contextClause.type) {
     case "prepositions":
-      return ArrayResult.combine(...contextClause.prepositions.map(preposition))
+      return IterableResult.combine(
+        ...contextClause.prepositions.map(preposition),
+      )
         .map((prepositions) =>
           prepositions.map((preposition) => ({
             ...preposition,
@@ -220,12 +222,14 @@ export function contextClause(
           emphasis: false,
         }]);
     case "anu":
-      return ArrayResult.errors([
+      return IterableResult.errors([
         new TranslationTodoError(`${contextClause.type} context clause`),
       ]);
     default:
-      return ArrayResult.concat<ReadonlyArray<English.Clause>>(
-        new ArrayResult(nullableAsArray(unwrapSingleWord(contextClause)))
+      return IterableResult.concat<ReadonlyArray<English.Clause>>(
+        IterableResult.fromArray(
+          nullableAsArray(unwrapSingleWord(contextClause)),
+        )
           .flatMap((wordUnit) =>
             fromSimpleDefinition(
               wordUnit,

src/translator/determiner.ts

@@ -1,6 +1,6 @@
 import { zip } from "@std/collections/zip";
 import * as Dictionary from "../../dictionary/type.ts";
-import { ArrayResult } from "../compound.ts";
+import { IterableResult } from "../compound.ts";
 import * as English from "./ast.ts";
 import { FilteredError } from "./error.ts";
 import { simpleNounForms } from "./noun.ts";
@@ -50,7 +50,7 @@ export function determiner(
     reduplicationCount: number;
     emphasis: boolean;
   }>,
-): ArrayResult<English.Determiner> {
+): IterableResult<English.Determiner> {
   const { definition } = options;
   return simpleNounForms({
     singular: definition.determiner,