use method instead

Author: neverRare

dictionary/parser.ts

@@ -490,24 +490,22 @@ const dictionaryParser = spaces
         words.map((word) => [word, definition])
       ),
     )
-  )
-  .generateParser();
+  );
 
 const definitionExtractor = spaces
   .with(all(optionalAll(lex(head)).with(lex(match(/[^;]*;/, "definition")))))
-  .skip(end)
-  .generateParser();
-const definitionParser = spaces.with(definition).skip(end).generateParser();
+  .skip(end);
+const definitionParser = spaces.with(definition).skip(end);
 
 export function parseDictionary(sourceText: string): Dictionary {
-  const arrayResult = dictionaryParser(sourceText);
+  const arrayResult = dictionaryParser.parse(sourceText);
   if (!arrayResult.isError()) {
     return arrayResult.array[0];
   } else {
-    const definitions = definitionExtractor(sourceText);
+    const definitions = definitionExtractor.parse(sourceText);
     const errors = !definitions.isError()
       ? definitions.array[0].flatMap((definition) =>
-        definitionParser(definition).errors.map((error) =>
+        definitionParser.parse(definition).errors.map((error) =>
           new ArrayResultError(
             `${error.message} at ${definition.trim()}`,
             { cause: error },

src/parser/parser.ts

@@ -713,7 +713,7 @@ const sentence = choice<Sentence>(
     })),
 )
   .filter(filter(SENTENCE_RULE));
-export const parse = spaces
+export const parser = spaces
   .with(
     lookAhead(everything.filter((source) =>
       source.trimEnd().length <= 500 ||
@@ -728,5 +728,4 @@ export const parse = spaces
       .skip(end)
       .filter(filter(MULTIPLE_SENTENCES_RULE))
       .map((sentences) => ({ type: "sentences", sentences })),
-  ))
-  .generateParser();
+  ));

src/parser/parser_lib.ts

@@ -19,20 +19,17 @@ export class Parser<T> {
       { cache },
     );
   }
-  generateParser(): (source: string) => ArrayResult<T> {
-    return (source) => {
-      currentSource = source;
-      for (const memo of allMemo) {
-        const ref = memo.deref();
-        if (ref == null) {
-          allMemo.delete(memo);
-        } else {
-          ref.clear();
-        }
+  parse(source: string): ArrayResult<T> {
+    currentSource = source;
+    for (const memo of allMemo) {
+      const ref = memo.deref();
+      if (ref == null) {
+        allMemo.delete(memo);
+      } else {
+        ref.clear();
       }
-      return this.rawParser(0)
-        .map(({ value }) => value);
-    };
+    }
+    return this.rawParser(0).map(({ value }) => value);
   }
   map<U>(mapper: (value: T) => U): Parser<U> {
     return new Parser((input) =>

src/parser/test.ts

@@ -5,13 +5,13 @@ import { assertLess } from "@std/assert/less";
 import { assertNotEquals } from "@std/assert/not-equals";
 import { assertThrows } from "@std/assert/throws";
 import { EXAMPLE_SENTENCES, MALFORMED_SENTENCES } from "../examples.ts";
-import { parse } from "./parser.ts";
+import { parser } from "./parser.ts";
 import { all, end, many, match, matchString, sequence } from "./parser_lib.ts";
 import { KU_LILI, KU_SULI, PU } from "./ucsur.ts";
 
 Deno.test("AST all distinct", () => {
   for (const sentence of EXAMPLE_SENTENCES) {
-    const pairs = uniquePairs(parse(sentence).unwrap());
+    const pairs = uniquePairs(parser.parse(sentence).unwrap());
     for (const [a, b] of pairs) {
       assertNotEquals(a, b, `Error at "${sentence}"`);
     }
@@ -20,7 +20,7 @@ Deno.test("AST all distinct", () => {
 
 Deno.test("parser all error", () => {
   for (const sentence of MALFORMED_SENTENCES) {
-    assertThrows(() => parse(sentence).unwrap());
+    assertThrows(() => parser.parse(sentence).unwrap());
   }
 });
 
@@ -57,21 +57,18 @@ Deno.test("small parser", () => {
     match(/toki/, '"toki"').skip(space),
     matchString("pona").skip(space),
     match(/a/, '"a"').skip(end),
-  )
-    .generateParser();
-  assertEquals(parser("toki pona a").unwrap(), [["toki", "pona", "a"]]);
+  );
+  assertEquals(parser.parse("toki pona a").unwrap(), [["toki", "pona", "a"]]);
 });
 
 Deno.test("many", () => {
   const space = match(/\s*/, "space");
-  const parser = many(matchString("a").skip(space)).skip(end)
-    .generateParser();
-  assertEquals(parser("a a a").unwrap(), [["a", "a", "a"]]);
+  const parser = many(matchString("a").skip(space)).skip(end);
+  assertEquals(parser.parse("a a a").unwrap(), [["a", "a", "a"]]);
 });
 
 Deno.test("all", () => {
   const space = match(/\s*/, "space");
-  const parser = all(matchString("a").skip(space)).skip(end)
-    .generateParser();
-  assertEquals(parser("a a a").unwrap(), [["a", "a", "a"]]);
+  const parser = all(matchString("a").skip(space)).skip(end);
+  assertEquals(parser.parse("a a a").unwrap(), [["a", "a", "a"]]);
 });

src/translator/translator.ts

@@ -1,10 +1,11 @@
 import { ArrayResult } from "../array_result.ts";
-import { parse } from "../parser/parser.ts";
+import { parser } from "../parser/parser.ts";
 import * as EnglishComposer from "./composer.ts";
 import { multipleSentences } from "./sentence.ts";
 
 export function translate(text: string): ArrayResult<string> {
-  return parse(text)
+  return parser
+    .parse(text)
     .flatMap(multipleSentences)
     .map(EnglishComposer.multipleSentences);
 }