refactor

Author: neverRare

dictionary/parser.ts

@@ -257,7 +257,7 @@ const checkedNoun = new CheckedParser(
   ),
   noun,
 );
-function simpleDefinitionWith<T>(
+function checkedSimpleUnitWith<T>(
   tag: Parser<unknown>,
   after: Parser<T>,
 ): CheckedParser<readonly [string, T]> {
@@ -266,30 +266,33 @@ function simpleDefinitionWith<T>(
     closeParenthesis.with(after),
   );
 }
-function simpleDefinition(tag: Parser<unknown>): CheckedParser<string> {
-  return simpleDefinitionWith(tag, nothing).map(([word]) => word);
+function checkedSimpleUnit(tag: Parser<unknown>): CheckedParser<string> {
+  return checkedSimpleUnitWith(tag, nothing).map(([word]) => word);
 }
-function simpleDefinitionWithTemplate(
+function checkedSimpleUnitWithTemplate(
   tag: Parser<unknown>,
   templateInside: Parser<unknown>,
 ): CheckedParser<string> {
-  return simpleDefinitionWith(tag, template(templateInside))
+  return checkedSimpleUnitWith(tag, template(templateInside))
     .map(([word]) => word);
 }
-const interjectionDefinition = simpleDefinition(keyword("i"))
+const interjectionDefinition = checkedSimpleUnit(keyword("i"))
   .map((interjection) => ({ type: "interjection", interjection }) as const);
-const particleDefinition = simpleDefinition(
-  sequence(keyword("particle"), keyword("def")),
+const particleDefinition = checkedSequence(
+  word.skip(openParenthesis).skip(keyword("particle")),
+  sequence(keyword("def"), closeParenthesis),
 )
-  .map((definition) => ({ type: "particle definition", definition }) as const);
-const adverbDefinition = simpleDefinition(keyword("adv"))
+  .map(([definition]) =>
+    ({ type: "particle definition", definition }) as const
+  );
+const adverbDefinition = checkedSimpleUnit(keyword("adv"))
   .map((adverb) => ({ type: "adverb", adverb }) as const);
-const prepositionDefinition = simpleDefinitionWithTemplate(
+const prepositionDefinition = checkedSimpleUnitWithTemplate(
   keyword("prep"),
   sequence(keyword("indirect"), keyword("object")),
 )
   .map((preposition) => ({ type: "preposition", preposition }) as const);
-const numeralDefinition = simpleDefinition(keyword("num"))
+const numeralDefinition = checkedSimpleUnit(keyword("num"))
   .mapWithPositionedError((num) => {
     const numeral = Number.parseInt(num);
     if (Number.isNaN(numeral)) {
@@ -394,7 +397,7 @@ const nounDefinition = new CheckedParser(
   sequence(
     noun,
     optionalWithCheck(
-      simpleDefinitionWithTemplate(keyword("prep"), keyword("headword")),
+      checkedSimpleUnitWithTemplate(keyword("prep"), keyword("headword")),
     ),
   ),
 )
@@ -430,7 +433,7 @@ const verbDefinition = checkedSequence(
       sequence(closeParenthesis, openBracket, keyword("object")),
       closeBracket
         .with(optionalWithCheck(
-          simpleDefinitionWith(keyword("prep"), noun)
+          checkedSimpleUnitWith(keyword("prep"), noun)
             .map(([preposition, object]) => ({ preposition, object }) as const),
         ))
         .map(nullableAsArray),
@@ -474,7 +477,7 @@ const verbDefinition = checkedSequence(
             optionalWithCheck(checkedNoun),
           ),
         optionalWithCheck(
-          simpleDefinitionWith(
+          checkedSimpleUnitWith(
             keyword("prep"),
             choiceWithCheck<"template" | Noun>(
               checkedSequence(

src/dictionary.ts

@@ -37,9 +37,7 @@ function update(): void {
   }
   redefineSet(
     contentWordSet,
-    ({ type }) =>
-      type !== "filler" &&
-      type !== "particle definition",
+    ({ type }) => !["filler", "particle definition"].includes(type),
   );
   redefineSetWithType(prepositionSet, "preposition");
   redefineSet(

src/parser/test.ts

@@ -40,11 +40,6 @@ Deno.test("no ali", () => {
     assertNotEquals(word, "ali");
   }
 });
-function uniquePairs<T>(
-  array: ReadonlyArray<T>,
-): ReadonlyArray<readonly [T, T]> {
-  return array.flatMap((a, i) => array.slice(i + 1).map((b) => [a, b]));
-}
 Deno.test("small parser", () => {
   const space = match(/\s*/, "space");
   const parser = sequence(
@@ -64,3 +59,8 @@ Deno.test("all", () => {
   const parser = all(matchString("a").skip(space)).skip(end);
   assertEquals(parser.parse("a a a").unwrap(), [["a", "a", "a"]]);
 });
+function uniquePairs<T>(
+  array: ReadonlyArray<T>,
+): ReadonlyArray<readonly [T, T]> {
+  return array.flatMap((a, i) => array.slice(i + 1).map((b) => [a, b]));
+}

src/translator/composer.ts

@@ -109,18 +109,16 @@ export function verb(phrase: English.VerbPhrase, depth: number): string {
   ]
     .join(" ");
 }
-function defaultClause(clause: English.Clause & { type: "default" }): string {
-  const subject = !clause.hideSubject ? [noun(clause.subject, 0)] : [];
-  return [
-    ...subject,
-    verb(clause.verb, 0),
-  ]
-    .join(" ");
-}
 function clause(ast: English.Clause): string {
   switch (ast.type) {
-    case "default":
-      return defaultClause(ast);
+    case "default": {
+      const subject = !ast.hideSubject ? [noun(ast.subject, 0)] : [];
+      return [
+        ...subject,
+        verb(ast.verb, 0),
+      ]
+        .join(" ");
+    }
     case "interjection":
       return word(ast.interjection);
     case "subject phrase":

src/translator/test.ts

@@ -12,30 +12,30 @@ Deno.test("adjective with adverb", () => {
   const translations = translate("pona ike").unwrap();
   assertArrayIncludes(translations, ["Badly good"]);
 });
-const NUMBER_TESTS = new Map(Object.entries({
-  "tu tu tu wan": 7,
-  "luka tu": 7,
-  "mute mute mute luka luka luka tu wan": 78,
-  "wan": 1,
-  "tu": 2,
-  "tu wan": 3,
-  "tu tu": 4,
-  "luka": 5,
-  "tu tu wan": 5,
-  "luka wan": 6,
-  "mute": 20,
-  "luka luka luka luka": 20,
-  "mute luka luka luka wan": 36,
-  "ale": 100,
-  "mute mute mute mute mute": 100,
-  "ale ale ale": 300,
-  "wan ale": 100,
-  "tu wan ale": 300,
-  "luka luka ale": 1000,
-  "wan ale ale": 10000,
-  "mute ale mute tu tu": 2024,
-}));
 Deno.test("numeral translation", () => {
+  const NUMBER_TESTS = new Map(Object.entries({
+    "tu tu tu wan": 7,
+    "luka tu": 7,
+    "mute mute mute luka luka luka tu wan": 78,
+    "wan": 1,
+    "tu": 2,
+    "tu wan": 3,
+    "tu tu": 4,
+    "luka": 5,
+    "tu tu wan": 5,
+    "luka wan": 6,
+    "mute": 20,
+    "luka luka luka luka": 20,
+    "mute luka luka luka wan": 36,
+    "ale": 100,
+    "mute mute mute mute mute": 100,
+    "ale ale ale": 300,
+    "wan ale": 100,
+    "tu wan ale": 300,
+    "luka luka ale": 1000,
+    "wan ale ale": 10000,
+    "mute ale mute tu tu": 2024,
+  }));
   for (const [tokiPona, expected] of NUMBER_TESTS) {
     const numbers = number(tokiPona.trim().split(" ")).unwrap();
     assertArrayIncludes(numbers, [expected], `Error at "${tokiPona}"`);

telo_misikeke/update.ts

@@ -29,7 +29,10 @@ async function buildCode(
   destination: URL,
   exportItems: ReadonlyArray<string>,
 ): Promise<void> {
-  const response = assertOk(await retry(() => fetch(source)));
+  const response = await retry(() => fetch(source));
+  if (!response.ok) {
+    throw new Error(`unable to fetch ${response.url} (${response.statusText})`);
+  }
   const rawCode = await response.text();
   const withoutCjs = rawCode.replaceAll(COMMONJS_EXPORT, "");
   if (withoutCjs.includes("module.exports")) {
@@ -60,13 +63,3 @@ if (import.meta.main) {
   // deno-lint-ignore no-console
   console.log("Updated telo misikeke.");
 }
-function assertOk(response: Response): Response {
-  if (!response.ok) {
-    const { url, status, statusText } = response;
-    throw new Error(
-      `unable to fetch ${url} (${status} ${statusText})`,
-    );
-  } else {
-    return response;
-  }
-}